org.fxmisc.richtext.GenericStyledArea Java Examples

@Test
public void clear() {
    GenericStyledArea codeAreaNode = (GenericStyledArea) getPrimaryStage().getScene().getRoot().lookup(".code-area");
    Platform.runLater(() -> {
        codeArea.marathon_select("Hello World");
    });
    new Wait("Waiting for the text area value to be set") {
        @Override
        public boolean until() {
            return "Hello World".equals(codeAreaNode.getText());
        }
    };
    codeArea.clear();
    new Wait("Waiting for the text area value to be cleared") {
        @Override
        public boolean until() {
            return "".equals(codeAreaNode.getText());
        }
    };
}
 

@Test
public void getText() {
    final GenericStyledArea textArea = (GenericStyledArea) getPrimaryStage().getScene().getRoot().lookup(".code-area");
    LoggingRecorder lr = new LoggingRecorder();
    List<Object> text = new ArrayList<>();
    Platform.runLater(() -> {
        RFXComponent rca = new RFXGenericStyledArea(textArea, null, null, lr);
        textArea.appendText("Hello World");
        rca.focusLost(null);
        text.add(rca.getAttribute("text"));
    });
    new Wait("Waiting for text area text.") {
        @Override
        public boolean until() {
            return text.size() > 0;
        }
    };
    AssertJUnit.assertEquals("Hello World", text.get(0));
}
 

@Test
public void selectWithSpecialChars() throws InterruptedException {
    final GenericStyledArea codeArea = (GenericStyledArea) getPrimaryStage().getScene().getRoot().lookup(".code-area");
    Platform.runLater(new Runnable() {
        @Override
        public void run() {
            codeArea.appendText("Hello\n World'\"");
        }
    });
    LoggingRecorder lr = new LoggingRecorder();
    RFXComponent rTextField = new RFXGenericStyledArea(codeArea, null, null, lr);
    Platform.runLater(new Runnable() {
        @Override
        public void run() {
            rTextField.focusLost(null);
        }
    });
    List<Recording> recordings = lr.waitAndGetRecordings(1);
    Recording select = recordings.get(0);
    AssertJUnit.assertEquals("recordSelect", select.getCall());
    AssertJUnit.assertEquals("Hello\n World'\"", select.getParameters()[0]);
}
 

@Test
public void selectWithUtf8Chars() throws InterruptedException {
    final GenericStyledArea codeArea = (GenericStyledArea) getPrimaryStage().getScene().getRoot().lookup(".code-area");
    Platform.runLater(new Runnable() {
        @Override
        public void run() {
            codeArea.appendText("å∫ç∂´ƒ©˙ˆ∆");
        }
    });
    LoggingRecorder lr = new LoggingRecorder();
    RFXComponent rTextField = new RFXGenericStyledArea(codeArea, null, null, lr);
    Platform.runLater(new Runnable() {
        @Override
        public void run() {
            rTextField.focusLost(null);
        }
    });
    List<Recording> recordings = lr.waitAndGetRecordings(1);
    Recording select = recordings.get(0);
    AssertJUnit.assertEquals("recordSelect", select.getCall());
    AssertJUnit.assertEquals("å∫ç∂´ƒ©˙ˆ∆", select.getParameters()[0]);
}
 

/**
 * Returns an UndoManager with an unlimited history that can undo/redo {@link RichTextChange}s. New changes
 * emitted from the stream will not be merged with the previous change after {@code preventMergeDelay}.
 * <p><b>Note</b>: that <u>only styling changes</u> may occur <u>during suspension</u> of the undo manager.
 */
public static <PS, SEG, S> UndoManager<List<RichTextChange<PS, SEG, S>>> richTextSuspendableUndoManager(
        GenericStyledArea<PS, SEG, S> area, Duration preventMergeDelay, SuspendableYes suspendUndo) {

    RichTextChange.skipStyleComparison( true );

    return new MultiChangeUndoManagerImpl<>
    (
        new UnlimitedChangeQueue<>(),
        TextChange::invert,
        applyMultiRichTextChange(area),
        TextChange::mergeWith,
        TextChange::isIdentity,
        area.multiRichChanges().conditionOn(suspendUndo),
        preventMergeDelay
    );
}
 

public static int entityEnd(int entityIndex, String[] array, GenericStyledArea<?, ?, ?> area) {
    if (entityIndex == array.length - 1) {
        return area.getLength();
    } else {
        return entityStart(entityIndex + 1, array) - 1;
    }
}
 

@Test
public void marathon_select() {
    GenericStyledArea codeAreaNode = (GenericStyledArea) getPrimaryStage().getScene().getRoot().lookup(".code-area");
    Platform.runLater(() -> {
        codeArea.marathon_select("Hello World");
    });
    new Wait("Waiting for the text area value to be set") {
        @Override
        public boolean until() {
            return "Hello World".equals(codeAreaNode.getText());
        }
    };
}
 

private static void moveToChange( GenericStyledArea area, TextChange chg )
{
    int pos = chg.getPosition();
    int len = chg.getNetLength();
    if ( len > 0 ) pos += len;

    area.moveTo( Math.min( pos, area.getLength() ) );
}
 

/**
 * Applies a list of {@link RichTextChange} to the given area when the {@link UndoManager}'s change stream emits
 * an event by {@code area.replaceAbsolutely(change.getPosition(), change.getRemovalEnd(), change.getInserted()}.
 */
public static <PS, SEG, S> Consumer<List<RichTextChange<PS, SEG, S>>> applyMultiRichTextChange(
        GenericStyledArea<PS, SEG, S> area) {
    return changeList -> {
        MultiChangeBuilder<PS, SEG, S> builder = area.createMultiChange(changeList.size());
        for (RichTextChange<PS, SEG, S> c : changeList) {
            builder.replaceAbsolutely(c.getPosition(), c.getRemovalEnd(), c.getInserted());
        }
        builder.commit();
        moveToChange( area, changeList.get( changeList.size()-1 ) );
    };
}
 

/**
 * Applies a list of {@link PlainTextChange}s to the given area when the {@link UndoManager}'s change stream emits
 * an event by {@code area.replaceAbsolutely(change.getPosition(), change.getRemovalEnd(), change.getInserted()}.
 */
public static <PS, SEG, S> Consumer<List<PlainTextChange>> applyMultiPlainTextChange(
        GenericStyledArea<PS, SEG, S> area) {
    return changeList -> {
        MultiChangeBuilder<PS, SEG, S> builder = area.createMultiChange(changeList.size());
        for (PlainTextChange c : changeList) {
            builder.replaceTextAbsolutely(c.getPosition(), c.getRemovalEnd(), c.getInserted());
        }
        builder.commit();
        moveToChange( area, changeList.get( changeList.size()-1 ) );
    };
}
 

/**
 * Applies a {@link RichTextChange} to the given area when the {@link UndoManager}'s change stream emits an event
 * by {@code area.replace(change.getPosition(), change.getRemovalEnd(), change.getInserted()}.
 */
public static <PS, SEG, S> Consumer<RichTextChange<PS, SEG, S>> applyRichTextChange(
        GenericStyledArea<PS, SEG, S> area) {
    return change -> {
        area.replace(change.getPosition(), change.getRemovalEnd(), change.getInserted());
        moveToChange( area, change );
    };
}
 

/**
 * Applies a {@link PlainTextChange} to the given area when the {@link UndoManager}'s change stream emits an event
 * by {@code area.replaceText(change.getPosition(), change.getRemovalEnd(), change.getInserted()}.
 */
public static <PS, SEG, S> Consumer<PlainTextChange> applyPlainTextChange(GenericStyledArea<PS, SEG, S> area) {
    return change -> {
        area.replaceText(change.getPosition(), change.getRemovalEnd(), change.getInserted());
        moveToChange( area, change );
    };
}
 

/**
 * Returns an UndoManager that can undo/redo {@link PlainTextChange}s. New changes
 * emitted from the stream will not be merged with the previous change
 * after {@code preventMergeDelay}
 */
public static <PS, SEG, S> UndoManager<List<PlainTextChange>> plainTextUndoManager(
        GenericStyledArea<PS, SEG, S> area, UndoManagerFactory factory, Duration preventMergeDelay) {
    return factory.createMultiChangeUM(area.multiPlainChanges(),
            TextChange::invert,
            applyMultiPlainTextChange(area),
            TextChange::mergeWith,
            TextChange::isIdentity,
            preventMergeDelay);
}
 

/**
 * Returns an UndoManager that can undo/redo {@link RichTextChange}s. New changes
 * emitted from the stream will not be merged with the previous change
 * after {@code preventMergeDelay}
 */
public static <PS, SEG, S> UndoManager<List<RichTextChange<PS, SEG, S>>> richTextUndoManager(
        GenericStyledArea<PS, SEG, S> area, UndoManagerFactory factory, Duration preventMergeDelay) {
    return factory.createMultiChangeUM(area.multiRichChanges(),
            TextChange::invert,
            applyMultiRichTextChange(area),
            TextChange::mergeWith,
            TextChange::isIdentity,
            preventMergeDelay);
}
 

@Test
public void getText() {
    GenericStyledArea codeAreaNode = (GenericStyledArea) getPrimaryStage().getScene().getRoot().lookup(".code-area");
    AssertJUnit.assertEquals("", codeArea.getText());
    Platform.runLater(() -> {
        codeArea.marathon_select("Hello World");
    });
    new Wait("Waiting for the text area value to be set") {
        @Override
        public boolean until() {
            return "Hello World".equals(codeAreaNode.getText());
        }
    };
    AssertJUnit.assertEquals("Hello World", codeArea.getText());
}
 

/**
 * Constructs an UndoManager with an unlimited history:
 * if {@link GenericStyledArea#isPreserveStyle() the area's preserveStyle flag is true}, the returned UndoManager
 * can undo/redo multiple {@link RichTextChange}s; otherwise, it can undo/redo multiple {@link PlainTextChange}s.
 */
public static <PS, SEG, S> UndoManager defaultUndoManager(GenericStyledArea<PS, SEG, S> area) {
    return area.isPreserveStyle()
            ? richTextUndoManager(area)
            : plainTextUndoManager(area);
}
 

public BulletFactory( GenericStyledArea<ParStyle,?,?> area )
{
    this.area = area;
}
 

/**
 * Returns an UndoManager with an unlimited history that can undo/redo {@link RichTextChange}s. New changes
 * emitted from the stream will not be merged with the previous change after {@link #DEFAULT_PREVENT_MERGE_DELAY}
 * <p><b>Note</b>: that <u>only styling changes</u> may occur <u>during suspension</u> of the undo manager.
 */
public static <PS, SEG, S> UndoManager<List<RichTextChange<PS, SEG, S>>> richTextSuspendableUndoManager(
        GenericStyledArea<PS, SEG, S> area, SuspendableYes suspendUndo) {
    return richTextSuspendableUndoManager(area, DEFAULT_PREVENT_MERGE_DELAY, suspendUndo);
}
 

/**
 * Returns an UndoManager with an unlimited history that can undo/redo {@link PlainTextChange}s. New changes
 * emitted from the stream will not be merged with the previous change
 * after {@link #DEFAULT_PREVENT_MERGE_DELAY}
 */
public static <PS, SEG, S> UndoManager<List<PlainTextChange>> plainTextUndoManager(
        GenericStyledArea<PS, SEG, S> area) {
    return plainTextUndoManager(area, DEFAULT_PREVENT_MERGE_DELAY);
}
 

/**
 * Returns an UndoManager that can undo/redo {@link PlainTextChange}s. New changes
 * emitted from the stream will not be merged with the previous change
 * after {@code preventMergeDelay}
 */
public static <PS, SEG, S> UndoManager<List<PlainTextChange>> plainTextUndoManager(
        GenericStyledArea<PS, SEG, S> area, Duration preventMergeDelay) {
    return plainTextUndoManager(area, UndoManagerFactory.unlimitedHistoryFactory(), preventMergeDelay);
}
 

/**
 * Returns an UndoManager that can undo/redo {@link PlainTextChange}s. New changes
 * emitted from the stream will not be merged with the previous change
 * after {@link #DEFAULT_PREVENT_MERGE_DELAY}
 */
public static <PS, SEG, S> UndoManager<List<PlainTextChange>> plainTextUndoManager(
        GenericStyledArea<PS, SEG, S> area, UndoManagerFactory factory) {
    return plainTextUndoManager(area, factory, DEFAULT_PREVENT_MERGE_DELAY);
}
 

/**
 * Returns an UndoManager that can undo/redo {@link RichTextChange}s. New changes
 * emitted from the stream will not be merged with the previous change
 * after {@link #DEFAULT_PREVENT_MERGE_DELAY}
 */
public static <PS, SEG, S> UndoManager<List<RichTextChange<PS, SEG, S>>> richTextUndoManager(
        GenericStyledArea<PS, SEG, S> area, UndoManagerFactory factory) {
    return richTextUndoManager(area, factory, DEFAULT_PREVENT_MERGE_DELAY);
}
 

/**
 * Returns an UndoManager that can undo/redo {@link RichTextChange}s. New changes
 * emitted from the stream will not be merged with the previous change
 * after {@code preventMergeDelay}
 */
public static <PS, SEG, S> UndoManager<List<RichTextChange<PS, SEG, S>>> richTextUndoManager(
        GenericStyledArea<PS, SEG, S> area, Duration preventMergeDelay) {
    return richTextUndoManager(area, UndoManagerFactory.unlimitedHistoryFactory(), preventMergeDelay);
}
 

/**
 * Returns an UndoManager with an unlimited history that can undo/redo {@link RichTextChange}s. New changes
 * emitted from the stream will not be merged with the previous change
 * after {@link #DEFAULT_PREVENT_MERGE_DELAY}
 */
public static <PS, SEG, S> UndoManager<List<RichTextChange<PS, SEG, S>>> richTextUndoManager(
        GenericStyledArea<PS, SEG, S> area) {
    return richTextUndoManager(area, UndoManagerFactory.unlimitedHistoryFactory());
}