IllegalArgumentException when undo-ing then redo-ing

[benedictleejh]

Steps to reproduce:

1. enter text "testtest"
2. Highlight the first "test"
3. style (Press the style button) the first "test"
4. Highlight the second "test"
5. style the second "test"
6. put selection point between the two "test"
7. type shift-space, space, space
8. undo, redo

Repo with code: https://github.com/benedictleejh/richtextfx-error

[TomasMikula]

Thanks for reporting. This is an example of how stricter checking in UndoFX revealed a bug elsewhere.

A little analysis of the problem:

The problem comes down to the fact that an empty paragraph contains one text segment (StyledText) of length 0, but there is a style associated with that text segment nevertheless. The two change events, expected and received, differ in the style of that empty string, and are thus considered different, even though their effect is indistinguishable.

I think the right solution is to represent an empty Paragraph as having no text segments. Though there are probably places where we use the style of an empty segment, so we will have to find a way to not need that style.

[JordanMartinez]

Here's the Java version of benedictleejh's code:

import javafx.application.Application;
import javafx.scene.Scene;
import javafx.scene.control.Button;
import javafx.scene.input.KeyEvent;
import javafx.scene.layout.BorderPane;
import javafx.stage.Stage;
import org.fxmisc.richtext.InlineStyleTextArea;

import java.util.function.Function;

public class BugTest extends Application {

    public static void main(String[] args) {
        launch(args);
    }

    class BoldUnderline {
        boolean styled;
        String style = "-fx-font-weight: bold; -fx-underline: true;";
        String toCss() { return (styled) ? style : ""; }

        BoldUnderline(boolean styled) {
            this.styled = styled;
        }
    }

    InlineStyleTextArea<BoldUnderline, String> richTextBox = new InlineStyleTextArea<>(
            new BoldUnderline(false), BoldUnderline::toCss,
            "", Function.identity()
            );
    {
        richTextBox.setPrefSize(400, 300);
        richTextBox.addEventFilter(KeyEvent.KEY_TYPED, (KeyEvent e) -> {
            if (e.isShiftDown() && e.getCharacter().equals(" ")) {
                richTextBox.setUseInitialStyleForInsertion(true);
                richTextBox.insertText(richTextBox.getCaretPosition(), " ");
                richTextBox.setUseInitialStyleForInsertion(false);

                // consume event to prevent double space insertion
                e.consume();
            }
        });
    }

    @Override
    public void start(Stage primaryStage) {
        Button styleBtn = new Button("Style");
        styleBtn.setOnAction((ae) -> {
            richTextBox.setStyle(
                    richTextBox.getSelection().getStart(),
                    richTextBox.getSelection().getEnd(),
                    new BoldUnderline(true)
            );
        });
        BorderPane root = new BorderPane();
        root.setTop(styleBtn);
        root.setCenter(richTextBox);
        primaryStage.setScene(new Scene(root));
        primaryStage.show();
    }
}

[JordanMartinez]

The problem comes down to the fact that an empty paragraph contains one text segment (StyledText) of length 0, but there is a style associated with that text segment nevertheless. The two change events, expected and received, differ in the style of that empty string, and are thus considered different, even though their effect is indistinguishable.

I understand this part, but I don't understand how you get to this conclusion...

I think the right solution is to represent an empty Paragraph as having no text segments. Though there are probably places where we use the style of an empty segment, so we will have to find a way to not need that style.

.... since the problem seems to be with StyledText as the exception occurs when the area only has one line (and hence one Paragraph), not two. Shouldn't the Paragraph immediately discard the empty StyledText? Why the reference to an empty Paragraph?

Could you explain your reasoning a bit more? This seems to be the last bug before the 0.7 release.

[TomasMikula]

Shouldn't the Paragraph immediately discard the empty StyledText? Why the reference to an empty Paragraph?

First, since there currently is the invariant that Paragraph always has at least one (possibly empty) StyledText, there is code that relies on it and does not have to check whether the Paragraph is empty, e.g. at Paragraph.java#L221, Paragraph.java#L246, and other places.

Secondly, the lines referred to above also return the style of the possibly empty text segment, which is used by EditableStyledDocument#getStyleForInsertionAt(), which in turn is used by EditableStyledDocument#replaceText().

[JordanMartinez]

Secondly, the lines referred to above also return the style of the possibly empty text segment, which is used by EditableStyledDocument#getStyleForInsertionAt(), which in turn is used by EditableStyledDocument#replaceText().

So, on one hand, the EditableStyledDocument#getStyleForInsertionAt() needs to account for a possibly empty paragraph. Something like the following code....

S getStyleForInsertionAt(Position insertionPos) {
    if(useInitialStyleForInsertion.get()) {
        return initialStyle;
    } else {
        Paragraph<S, PS> par = paragraphs.get(insertionPos.getMajor());
        // return style if paragraph isn't empty
        if (par.length() != 0) {
            return par.getStyleAtPosition(insertionPos.getMinor());
        } else {
            // find the first non-empty previous paragraph
            // and get style of the last character on the line
            for(int i = insertionPos.getMajor() - 1; i >= 0; i--) {
                Paragraph<S, PS> paragraph = paragraphs.get(i);
                if (paragraph.length() != 0) {
                    return paragraph.getStyleAtPosition(paragraph.length());
                }
            }

            // if not returned by now, find the first non-empty next paragraph
            // and get style of first character on the line
            for(int i = insertionPos.getMajor() + 1; i <= paragraphs.size() - 1; i++) {
                Paragraph<S, PS> paragraph = paragraphs.get(i);
                if (paragraph.length() != 0) {
                    return par.getStyleAtPosition(0);
                }
            }
            // if no style found, default to initialStyle
            return initialStyle;
        }
    }
}

....because EditableStyledDocument is the only one with access to other Paragraphs whose styles can be used if the chosen Paragraph is empty.

First, since there currently is the invariant that Paragraph always has at least one (possibly empty) StyledText, there is code that relies on it and does not have to check whether the Paragraph is empty, e.g. at Paragraph.java#L221, Paragraph.java#L246, and other places.

If a Paragraph is empty, it has no access to the previous and next Paragraphs. Even if it had a reference to initialStyle, which it doesn't, using that style wouldn't maintain the previous or next lines' styles and might break the user's expectations. So, an empty Paragraph would need to delegate the Style returned from getStyleAtPosition() to EditableStyledDocument using the above code.

I don't know entirely how the Paragraph objects work in relation to their view, ParagraphBox, but one idea I want to propose (not knowing its full implications) is to create a new class EmptyParagraph. It and Paragraph could implement some interface. Then, EmptyParagraph and Paragraph could be switched out under different circumstances: the empty one to a normal one when text is inserted and the normal one to an empty one when all text on a line is deleted.

Perhaps a better implementation of this idea is to add some code that delegates the getStyleAtPosition method to EditableStyledDocument (by adding a Function argument to its Constructor) when its length is 0.

[TomasMikula]

Paragraph cannot have a reference to EditableStyledDocument (directly or via a function argument), because the same paragraph may be present in multiple documents at the same time.

Having two implementations of Paragraph, empty and non-empty, might be a good idea. Maybe if the EmptyParagraph had a textStyle field that would be returned from its getStyleAtPosition(0) method, it would solve the problem of what to return from getStyleAtPosition.

[JordanMartinez]

Paragraph cannot have a reference to EditableStyledDocument (directly or via a function argument), because the same paragraph may be present in multiple documents at the same time.

Like when something needs to be replaced/inserted/deleted via ReadOnlyStyledDocument? Good point...

Having two implementations of Paragraph, empty and non-empty, might be a good idea. Maybe if the EmptyParagraph had a textStyle field that would be returned from its getStyleAtPosition(0) method, it would solve the problem of what to return from getStyleAtPosition.

Since we're dealing with a blank line, the Style object returned really doesn't matter (in terms of changing how the line is visually displayed). It only needs to satisfy a code requirement, correct? In that case, all that needs to be returned is a blank, empty, or default version of that Style object.
When text is inserted/deleted/replaced, etc., it can use the code I wrote above in EditableStyledDocument to handle the proper style insertion, right?

If so, it seems like the Style object should have a static method such as toEmptyLineCss() or a constant such as EMPTY_LINE_STYLE which the EmptyParagraph could return as a style in getStyleAtPosition(0).

[JordanMartinez]

If going that route, I think some interface should be created that all style-related objects must implement.

[benedictleejh]

I'd like to suggest that the empty paragraph should return the default style for the text area. I've run into an issue where if all the text in the text area was styled, deleting all the text and then trying to insert new text would cause the new text to inherit the deleted text's style.

I haven't filed an issue for that since @TomasMikula's explanation of this bug implies that if this was properly fixed, that would get fixed as a side effect. If you do prefer, I could certainly file an issue for that however.

[JordanMartinez]

After testing out my idea, I'm running into a couple of issues.:

Renaming Paragraph to NormalParagraph, creating EmptyParagraph, and creating an interface Paragraph<S, PS> that NormalParagraph and EmptyParagraph implement....

public interface Paragraph<S, PS> extends CharSequence {

    public List<StyledText<S>> getSegments();
    public PS getParagraphStyle();

    public String substring(int from, int to);
    public String substring(int from);
    public Paragraph<S, PS> concat(Paragraph<S, PS> p);
    public Paragraph<S, PS> concat(CharSequence str);
    public Paragraph<S, PS> insert(int offset, CharSequence str);
    public Paragraph<S, PS> subSequence(int start, int end);
    public Paragraph<S, PS> trim(int length);
    public Paragraph<S, PS> subSequence(int start);
    public Paragraph<S, PS> delete(int start, int end);

    public Paragraph<S, PS> restyle(S style);
    public Paragraph<S, PS> restyle(int from, int to, S style);
    public Paragraph<S, PS> restyle(int from, StyleSpans<? extends S> styleSpans);

    public Paragraph<S, PS> setParagraphStyle(PS paragraphStyle);
    public S getStyleOfChar(int charIdx);
    public S getStyleAtPosition(int position);
    public IndexRange getStyleRangeAtPosition(int position);
    public StyleSpans<S> getStyleSpans();
    public StyleSpans<S> getStyleSpans(int from, int to);
}

...EmptyParagraph runs into a few problems:

• What does EmptyParagraph return in overriding CharSequence's charAt() method?
• substring() returns an empty string. Will that lead to any problems down the road (like when getting the length of the String)?
• Methods with a CharSequence argument are problematic (concat(CharSequence str) and insert(CharSequence str)). These methods should create a NormalParagraph. However, what should that paragraph's text style object be? The reference to a blank style shouldn't be used, right?
• getStyleRangeAtPosition(int position) would return an EMPTY_RANGE ([0, 0]). Will that be problematic elsewhere since it's length is 0?
• What should be returned from getStyleSpans()? If null is returned, will that screw up code elsewhere?
• NormalParagraph's hashCode() hashes its paragraphStyle and its List<StyledText<S>> segments, which means each paragraph will be unique. However, EmptyParagraph's hashCode() would only hash its paragraphStyle and the emptyTextStyle used for getStyleAtPosition(0). Will that cause a problem?

Full class code below:

public class EmptyParagraph<S, PS> implements Paragraph<S, PS> {
    public static final IndexRange EMPTY_RANGE = new IndexRange(0, 0);

    private final PS paragraphStyle;
    private final S emptyTextStyle;

    public EmptyParagraph(PS paragraphStyle, S textStyle) {
        this.paragraphStyle = paragraphStyle;
        this.emptyTextStyle = textStyle;
    }

    public List<StyledText<S>> getSegments() {
        return Collections.unmodifiableList(new ArrayList<StyledText<S>>(0));
    }

    public PS getParagraphStyle() {
        return paragraphStyle;
    }

    @Override
    public int length() {
        return 0;
    }

    public String substring(int from, int to) {
        return "";
    }

    public String substring(int from) {
        return "";
    }

    public Paragraph<S, PS> concat(Paragraph<S, PS> p) {
        return p;
    }

    public Paragraph<S, PS> concat(CharSequence str) {
        if(str.length() == 0) {
            return this;
        }

        List<StyledText<S>> segs = new ArrayList<>(1);
        segs.set(0, new StyledText<S>(
                str.toString(),
                // what should be the style here?
                emptyTextStyle));
        return new NormalParagraph<>(paragraphStyle, segs);
    }

    public Paragraph<S, PS> insert(int offset, CharSequence str) {
        List<StyledText<S>> segs = new ArrayList<>(1);
        segs.set(0, new StyledText<S>(
                str.toString(),
                // what should be the style here?
                emptyTextStyle));
        return new NormalParagraph<>(paragraphStyle, segs);
    }

    @Override
    public Paragraph<S, PS> subSequence(int start, int end) {
        return this;
//        return trim(end).subSequence(start);
    }

    public Paragraph<S, PS> trim(int length) {
        return this;

//        if(length >= length()) {
//            return this;
//        } else {
//            TwoDimensional.Position pos = navigator.offsetToPosition(length, Backward);
//            int segIdx = pos.getMajor();
//            List<StyledText<S>> segs = new ArrayList<>(segIdx + 1);
//            segs.addAll(segments.subList(0, segIdx));
//            segs.add(segments.get(segIdx).subSequence(0, pos.getMinor()));
//            return new NormalParagraph<>(paragraphStyle, segs);
//        }
    }

    public Paragraph<S, PS> subSequence(int start) {
        return this;

//        if(start < 0) {
//            throw new IllegalArgumentException("start must not be negative (was: " + start + ")");
//        } else if(start == 0) {
//            return this;
//        } else if(start <= length()) {
//            TwoDimensional.Position pos = navigator.offsetToPosition(start, Forward);
//            int segIdx = pos.getMajor();
//            List<StyledText<S>> segs = new ArrayList<>(segments.size() - segIdx);
//            segs.add(segments.get(segIdx).subSequence(pos.getMinor()));
//            segs.addAll(segments.subList(segIdx + 1, segments.size()));
//            return new NormalParagraph<>(paragraphStyle, segs);
//        } else {
//            throw new IndexOutOfBoundsException(start + " not in [0, " + length() + "]");
//        }
    }

    public Paragraph<S, PS> delete(int start, int end) {
        return this;

//        return trim(start).concat(subSequence(end));
    }

    public Paragraph<S, PS> restyle(S style) {
        return new EmptyParagraph<>(paragraphStyle, style);

//        return new NormalParagraph<>(paragraphStyle, toString(), style);
    }

    public Paragraph<S, PS> restyle(int from, int to, S style) {
        return restyle(style);

//        if(from >= length()) {
//            return this;
//        } else {
//            to = Math.min(to, length());
//            Paragraph<S, PS> left = subSequence(0, from);
//            Paragraph<S, PS> middle = new NormalParagraph<>(paragraphStyle, substring(from, to), style);
//            Paragraph<S, PS> right = subSequence(to);
//            return left.concat(middle).concat(right);
//        }
    }

    public Paragraph<S, PS> restyle(int from, StyleSpans<? extends S> styleSpans) {
        return this;

//        int len = styleSpans.length();
//        if(styleSpans.equals(getStyleSpans(from, from + len))) {
//            return this;
//        }
//
//        Paragraph<S, PS> left = trim(from);
//        Paragraph<S, PS> right = subSequence(from + len);
//
//        String middleString = substring(from, from + len);
//        List<StyledText<S>> middleSegs = new ArrayList<>(styleSpans.getSpanCount());
//        int offset = 0;
//        for(StyleSpan<? extends S> span: styleSpans) {
//            int end = offset + span.getLength();
//            String text = middleString.substring(offset, end);
//            middleSegs.add(new StyledText<>(text, span.getStyle()));
//            offset = end;
//        }
//        Paragraph<S, PS> middle = new NormalParagraph<>(paragraphStyle, middleSegs);
//
//        return left.concat(middle).concat(right);
    }

    public Paragraph<S, PS> setParagraphStyle(PS paragraphStyle) {
        return new EmptyParagraph<>(paragraphStyle, emptyTextStyle);

//        return new NormalParagraph<>(paragraphStyle, segments);
    }

    /**
     * Returns the style of character with the given index.
     * If {@code charIdx < 0}, returns the style at the beginning of this paragraph.
     * If {@code charIdx >= this.length()}, returns the style at the end of this paragraph.
     */
    public S getStyleOfChar(int charIdx) {
        return emptyTextStyle;

//        if(charIdx < 0) {
//            return segments.get(0).getStyle();
//        }
//
//        TwoDimensional.Position pos = navigator.offsetToPosition(charIdx, Forward);
//        return segments.get(pos.getMajor()).getStyle();
    }

    /**
     * Returns the style at the given position. That is the style of the
     * character immediately preceding {@code position}. If {@code position}
     * is 0, then the style of the first character (index 0) in this paragraph
     * is returned. If this paragraph is empty, then some style previously used
     * in this paragraph is returned.
     * If {@code position > this.length()}, then it is equivalent to
     * {@code position == this.length()}.
     *
     * <p>In other words, {@code getStyleAtPosition(p)} is equivalent to
     * {@code getStyleOfChar(p-1)}.
     */
    public S getStyleAtPosition(int position) {
        return emptyTextStyle;

//        if(position < 0) {
//            throw new IllegalArgumentException("Paragraph position cannot be negative (" + position + ")");
//        }
//
//        TwoDimensional.Position pos = navigator.offsetToPosition(position, Backward);
//        return segments.get(pos.getMajor()).getStyle();
    }

    /**
     * Returns the range of homogeneous style that includes the given position.
     * If {@code position} points to a boundary between two styled ranges,
     * then the range preceding {@code position} is returned.
     */
    public IndexRange getStyleRangeAtPosition(int position) {
        return EMPTY_RANGE;

//        TwoDimensional.Position pos = navigator.offsetToPosition(position, Backward);
//        int start = position - pos.getMinor();
//        int end = start + segments.get(pos.getMajor()).length();
//        return new IndexRange(start, end);
    }

    public StyleSpans<S> getStyleSpans() {
        return null;

//        StyleSpansBuilder<S> builder = new StyleSpansBuilder<>(segments.size());
//        for(StyledText<S> seg: segments) {
//            builder.add(seg.getStyle(), seg.length());
//        }
//        return builder.create();
    }

    public StyleSpans<S> getStyleSpans(int from, int to) {
        return null;

//        TwoDimensional.Position start = navigator.offsetToPosition(from, Forward);
//        TwoDimensional.Position end = to == from
//                ? start
//                : start.offsetBy(to - from, Backward);
//        int startSegIdx = start.getMajor();
//        int endSegIdx = end.getMajor();
//
//        int n = endSegIdx - startSegIdx + 1;
//        StyleSpansBuilder<S> builder = new StyleSpansBuilder<>(n);
//
//        if(startSegIdx == endSegIdx) {
//            StyledText<S> seg = segments.get(startSegIdx);
//            builder.add(seg.getStyle(), to - from);
//        } else {
//            StyledText<S> startSeg = segments.get(startSegIdx);
//            builder.add(startSeg.getStyle(), startSeg.length() - start.getMinor());
//
//            for(int i = startSegIdx + 1; i < endSegIdx; ++i) {
//                StyledText<S> seg = segments.get(i);
//                builder.add(seg.getStyle(), seg.length());
//            }
//
//            StyledText<S> endSeg = segments.get(endSegIdx);
//            builder.add(endSeg.getStyle(), end.getMinor());
//        }
//
//        return builder.create();
    }

    /**
     * Returns the string content of this paragraph,
     * excluding the line terminator.
     */
    @Override
    public String toString() {
        return "";

//        if(text == null) {
//            StringBuilder sb = new StringBuilder(length());
//            for(StyledText<S> seg: segments)
//                sb.append(seg);
//            text = sb.toString();
//        }
//        return text;
    }

    @Override
    public char charAt(int index) {
        // what should be returned here?
        return 0;
    }

    @Override
    public boolean equals(Object other) {
        if(other instanceof EmptyParagraph) {
            EmptyParagraph<?, ?> that = (EmptyParagraph<?, ?>) other;
            return Objects.equals(this.paragraphStyle, that.paragraphStyle)
                    && Objects.equals(this.emptyTextStyle, that.emptyTextStyle);
        } else {
            return false;
        }
    }

    @Override
    public int hashCode() {
        // doesn't this lead to two EmptyParagraph objects having the same hash?
        return Objects.hash(paragraphStyle, emptyTextStyle);
    }
}

[JordanMartinez]

@benedictleejh That sounds to me like it's just a manifestation of this issue because, although the area doesn't have any text, the first Paragraph still has a StyledText object used to style any new insertions, hence the deleted style reappearing.

If the EditableStyledDocument code was implemented, the inserted text would be styled using the default style initialStyle in your described case because there wouldn't be any other style to use.

I have been quietly following the thread. Is this solvable by making the
insertionStyle user-defined. Then, it can be set to last used, or to
default initial style, or to any adhoc style, regardless if paragraph is
empty or not... no? (not a programmer here.. only a spectator...)

On Tue, Jan 12, 2016 at 7:52 PM, JordanMartinez notifications@github.com
wrote:

@benedictleejh https://github.com/benedictleejh That sounds to me like
it's just a manifestation of this issue because, although the area doesn't
have any text, the first Paragraph still has a StyledText object used to
style any new insertions, hence the deleted style reappearing.

If the EditableStyledDocument code was implemented, the inserted text
would be styled using the default style initialStyle in your described
case because there wouldn't be any other style to use.

—
Reply to this email directly or view it on GitHub
#216 (comment)
.

[JordanMartinez]

Mmm... I don't think so? I think the Exception would still be thrown even if that was allowed.

And isn't your prorposed idea sort of already allowed via
replace(int start, int end, ReadOnlyStyledDocument doc)
where one can specific the doc by using its factory method:
ReadOnlyStyledDocument.fromString(String str, S style, PS paragraphStyle)