Dave Jarvis' Repositories

1. Download [keenwrite.sh](https://raw.githubusercontent.com/DaveJarvis/keenwrite/master/keenwrite.sh).

# For GTK version, see https://bugs.openjdk.java.net/browse/JDK-8156779

-Djdk.gtk.version=2 \

--add-exports=javafx.graphics/com.sun.javafx.scene.text=ALL-UNNAMED \

  -jar keenwrite.jar

import javafx.scene.control.ContextMenu;

import javafx.scene.control.IndexRange;

import javafx.scene.control.MenuItem;

import javafx.scene.input.KeyEvent;

import javafx.scene.layout.BorderPane;

import org.fxmisc.flowless.VirtualizedScrollPane;

import org.fxmisc.richtext.StyleClassedTextArea;

import org.fxmisc.richtext.model.StyleSpans;

import org.fxmisc.undo.UndoManager;

import org.fxmisc.wellbehaved.event.EventPattern;

import org.fxmisc.wellbehaved.event.Nodes;

import java.io.File;

import java.nio.charset.Charset;

import java.text.BreakIterator;

import java.util.*;

import java.util.function.Consumer;

import java.util.function.Supplier;

import java.util.regex.Pattern;

import static com.keenwrite.MainApp.keyDown;

import static com.keenwrite.Messages.get;

import static com.keenwrite.constants.Constants.*;

import static com.keenwrite.events.StatusEvent.clue;

import static com.keenwrite.events.TextEditorFocusEvent.fireTextEditorFocus;

import static com.keenwrite.io.MediaType.TEXT_MARKDOWN;

import static com.keenwrite.io.MediaType.TEXT_R_MARKDOWN;

import static com.keenwrite.preferences.WorkspaceKeys.*;

import static java.lang.Character.isWhitespace;

import static java.lang.String.format;

import static java.util.Collections.singletonList;

import static javafx.application.Platform.runLater;

import static javafx.scene.control.ScrollPane.ScrollBarPolicy.ALWAYS;

import static javafx.scene.input.KeyCode.*;

import static javafx.scene.input.KeyCombination.*;

import static org.apache.commons.lang3.StringUtils.stripEnd;

import static org.apache.commons.lang3.StringUtils.stripStart;

import static org.fxmisc.richtext.model.StyleSpans.singleton;

import static org.fxmisc.wellbehaved.event.EventPattern.keyPressed;

import static org.fxmisc.wellbehaved.event.InputMap.consume;

/**

 * Responsible for editing Markdown documents.

 */

public final class MarkdownEditor extends BorderPane implements TextEditor {

  /**

   * Regular expression that matches the type of markup block. This is used

   * when Enter is pressed to continue the block environment.

   */

  private static final Pattern PATTERN_AUTO_INDENT = Pattern.compile(

    "(\\s*[*+-]\\s+|\\s*[0-9]+\\.\\s+|\\s+)(.*)" );

  /**

   * The text editor.

   */

  private final StyleClassedTextArea mTextArea =

    new StyleClassedTextArea( false );

  /**

   * Wraps the text editor in scrollbars.

   */

  private final VirtualizedScrollPane<StyleClassedTextArea> mScrollPane =

    new VirtualizedScrollPane<>( mTextArea );

  /**

   *

   */

  private final TextEditorSpeller mSpeller = new TextEditorSpeller();

  private final Workspace mWorkspace;

  /**

   * Tracks where the caret is located in this document. This offers observable

   * properties for caret position changes.

   */

  private final Caret mCaret = createCaret( mTextArea );

  /**

   * File being edited by this editor instance.

   */

  private File mFile;

  /**

   * Set to {@code true} upon text or caret position changes. Value is {@code

   * false} by default.

   */

  private final BooleanProperty mDirty = new SimpleBooleanProperty();

  /**

   * Opened file's character encoding, or {@link Constants#DEFAULT_CHARSET} if

   * either no encoding could be determined or this is a new (empty) file.

   */

  private final Charset mEncoding;

  /**

   * Tracks whether the in-memory definitions have changed with respect to the

   * persisted definitions.

   */

  private final BooleanProperty mModified = new SimpleBooleanProperty();

  public MarkdownEditor( final Workspace workspace ) {

    this( DOCUMENT_DEFAULT, workspace );

  }

  public MarkdownEditor( final File file, final Workspace workspace ) {

    mEncoding = open( mFile = file );

    mWorkspace = workspace;

    initTextArea( mTextArea );

    initStyle( mTextArea );

    initScrollPane( mScrollPane );

    initSpellchecker( mTextArea );

    initHotKeys();

    initUndoManager();

  }

  private void initTextArea( final StyleClassedTextArea textArea ) {

    textArea.setWrapText( true );

    textArea.requestFollowCaret();

    textArea.moveTo( 0 );

    textArea.textProperty().addListener( ( c, o, n ) -> {

      // Fire, regardless of whether the caret position has changed.

      mDirty.set( false );

      // Prevent a caret position change from raising the dirty bits.

      mDirty.set( true );

    } );

    textArea.caretPositionProperty().addListener( ( c, o, n ) -> {

      // Fire when the caret position has changed and the text has not.

      mDirty.set( true );

      mDirty.set( false );

    } );

    textArea.focusedProperty().addListener( ( c, o, n ) -> {

      if( n != null && n ) {

        fireTextEditorFocus( this );

      }

    } );

  }

  private void initStyle( final StyleClassedTextArea textArea ) {

    textArea.getStyleClass().add( "markdown" );

    final var stylesheets = textArea.getStylesheets();

    stylesheets.add( getStylesheetPath( getLocale() ) );

    localeProperty().addListener( ( c, o, n ) -> {

      if( n != null ) {

        stylesheets.clear();

        stylesheets.add( getStylesheetPath( getLocale() ) );

      }

    } );

    fontNameProperty().addListener(

      ( c, o, n ) ->

        setFont( mTextArea, getFontName(), getFontSize() )

    );

    fontSizeProperty().addListener(

      ( c, o, n ) ->

        setFont( mTextArea, getFontName(), getFontSize() )

    );

    setFont( mTextArea, getFontName(), getFontSize() );

  }

  private void initScrollPane(

    final VirtualizedScrollPane<StyleClassedTextArea> scrollpane ) {

    scrollpane.setVbarPolicy( ALWAYS );

    setCenter( scrollpane );

  }

  private void initSpellchecker( final StyleClassedTextArea textarea ) {

    mSpeller.checkDocument( textarea );

    mSpeller.checkParagraphs( textarea );

  }

  private void initHotKeys() {

    addEventListener( keyPressed( ENTER ), this::onEnterPressed );

    addEventListener( keyPressed( X, CONTROL_DOWN ), this::cut );

    addEventListener( keyPressed( TAB ), this::tab );

    addEventListener( keyPressed( TAB, SHIFT_DOWN ), this::untab );

    addEventListener( keyPressed( ENTER, ALT_DOWN ), this::autofix );

  }

  private void initUndoManager() {

    final var undoManager = getUndoManager();

    final var markedPosition = undoManager.atMarkedPositionProperty();

    undoManager.forgetHistory();

    undoManager.mark();

    mModified.bind( Bindings.not( markedPosition ) );

  }

  @Override

  public void moveTo( final int offset ) {

    assert 0 <= offset && offset <= mTextArea.getLength();

    mTextArea.moveTo( offset );

    mTextArea.requestFollowCaret();

  }

  /**

   * Delegate the focus request to the text area itself.

   */

  @Override

  public void requestFocus() {

    mTextArea.requestFocus();

  }

  @Override

  public void setText( final String text ) {

    mTextArea.clear();

    mTextArea.appendText( text );

    mTextArea.getUndoManager().mark();

  }

  @Override

  public String getText() {

    return mTextArea.getText();

  }

  @Override

  public Charset getEncoding() {

    return mEncoding;

  }

  @Override

  public File getFile() {

    return mFile;

  }

  @Override

  public void rename( final File file ) {

    mFile = file;

  }

  @Override

  public void undo() {

    final var manager = getUndoManager();

    xxdo( manager::isUndoAvailable, manager::undo, "Main.status.error.undo" );

  }

  @Override

  public void redo() {

    final var manager = getUndoManager();

    xxdo( manager::isRedoAvailable, manager::redo, "Main.status.error.redo" );

  }

  /**

   * Performs an undo or redo action, if possible, otherwise displays an error

   * message to the user.

   *

   * @param ready  Answers whether the action can be executed.

   * @param action The action to execute.

   * @param key    The informational message key having a value to display if

   *               the {@link Supplier} is not ready.

   */

  private void xxdo(

    final Supplier<Boolean> ready, final Runnable action, final String key ) {

    if( ready.get() ) {

      action.run();

    }

    else {

      clue( key );

    }

  }

  @Override

  public void cut() {

    final var selected = mTextArea.getSelectedText();

    // Emulate selecting the current line by firing Home then Shift+Down Arrow.

    if( selected == null || selected.isEmpty() ) {

      // Note: mTextArea.selectLine() does not select empty lines.

      mTextArea.fireEvent( keyDown( HOME, false ) );

      mTextArea.fireEvent( keyDown( DOWN, true ) );

    }

    mTextArea.cut();

  }

  @Override

  public void copy() {

    mTextArea.copy();

  }

  @Override

  public void paste() {

    mTextArea.paste();

  }

  @Override

  public void selectAll() {

    mTextArea.selectAll();

  }

  @Override

  public void bold() {

    enwrap( "**" );

  }

  @Override

  public void italic() {

    enwrap( "*" );

  }

  @Override

  public void monospace() {

    enwrap( "`" );

  }

  @Override

  public void superscript() {

    enwrap( "^" );

  }

  @Override

  public void subscript() {

    enwrap( "~" );

  }

  @Override

  public void strikethrough() {

    enwrap( "~~" );

  }

  @Override

  public void blockquote() {

    block( "> " );

  }

  @Override

  public void code() {

    enwrap( "`" );

  }

  @Override

  public void fencedCodeBlock() {

    enwrap( "\n\n```\n", "\n```\n\n" );

  }

  @Override

  public void heading( final int level ) {

    final var hashes = new String( new char[ level ] ).replace( "\0", "#" );

    block( format( "%s ", hashes ) );

  }

  @Override

  public void unorderedList() {

    block( "* " );

  }

  @Override

  public void orderedList() {

    block( "1. " );

  }

  @Override

  public void horizontalRule() {

    block( format( "---%n%n" ) );

  }

  @Override

  public Node getNode() {

    return this;

  }

  @Override

  public ReadOnlyBooleanProperty modifiedProperty() {

    return mModified;

  }

  @Override

  public void clearModifiedProperty() {

    getUndoManager().mark();

  }

  @Override

  public VirtualizedScrollPane<StyleClassedTextArea> getScrollPane() {

    return mScrollPane;

  }

  @Override

  public StyleClassedTextArea getTextArea() {

    return mTextArea;

  }

  private final Map<String, IndexRange> mStyles = new HashMap<>();

  @Override

  public void stylize( final IndexRange range, final String style ) {

    final var began = range.getStart();

    final var ended = range.getEnd() + 1;

    assert 0 <= began && began <= ended;

    assert style != null;

    // TODO: Ensure spell check and find highlights can coexist.

//    final var spans = mTextArea.getStyleSpans( range );

//    System.out.println( "SPANS: " + spans );

//    final var spans = mTextArea.getStyleSpans( range );

//    mTextArea.setStyleSpans( began, merge( spans, range.getLength(), style

//    ) );

//    final var builder = new StyleSpansBuilder<Collection<String>>();

//    builder.add( singleton( style ), range.getLength() + 1 );

//    mTextArea.setStyleSpans( began, builder.create() );

//    final var s = mTextArea.getStyleSpans( began, ended );

//    System.out.println( "STYLES: " +s );

    mStyles.put( style, range );

    mTextArea.setStyleClass( began, ended, style );

    // Ensure that whenever the user interacts with the text that the found

    // word will have its highlighting removed. The handler removes itself.

    // This won't remove the highlighting if the caret position moves by mouse.

    final var handler = mTextArea.getOnKeyPressed();

    mTextArea.setOnKeyPressed( ( event ) -> {

      mTextArea.setOnKeyPressed( handler );

      unstylize( style );

    } );

    //mTextArea.setStyleSpans(began, ended, s);

  }

  private static StyleSpans<Collection<String>> merge(

    StyleSpans<Collection<String>> spans, int len, String style ) {

    spans = spans.overlay(

      singleton( singletonList( style ), len ),

      ( bottomSpan, list ) -> {

        final List<String> l =

          new ArrayList<>( bottomSpan.size() + list.size() );

        l.addAll( bottomSpan );

        l.addAll( list );

        return l;

      } );

    return spans;

  }

  @Override

  public void unstylize( final String style ) {

    final var indexes = mStyles.remove( style );

    if( indexes != null ) {

      mTextArea.clearStyle( indexes.getStart(), indexes.getEnd() + 1 );

    }

  }

  @Override

  public Caret getCaret() {

    return mCaret;

  }

  private Caret createCaret( final StyleClassedTextArea editor ) {

    return Caret

      .builder()

      .with( Caret.Mutator::setEditor, editor )

      .build();

  }

  /**

   * This method adds listeners to editor events.

   *

   * @param <T>      The event type.

   * @param <U>      The consumer type for the given event type.

   * @param event    The event of interest.

   * @param consumer The method to call when the event happens.

   */

  public <T extends Event, U extends T> void addEventListener(

    final EventPattern<? super T, ? extends U> event,

    final Consumer<? super U> consumer ) {

    Nodes.addInputMap( mTextArea, consume( event, consumer ) );

  }

  private void onEnterPressed( final KeyEvent ignored ) {

    final var currentLine = getCaretParagraph();

    final var matcher = PATTERN_AUTO_INDENT.matcher( currentLine );

    // By default, insert a new line by itself.

    String newText = NEWLINE;

    // If the pattern was matched then determine what block type to continue.

    if( matcher.matches() ) {

      if( matcher.group( 2 ).isEmpty() ) {

        final var pos = mTextArea.getCaretPosition();

        mTextArea.selectRange( pos - currentLine.length(), pos );

      }

      else {

        // Indent the new line with the same whitespace characters and

        // list markers as current line. This ensures that the indentation

        // is propagated.

        newText = newText.concat( matcher.group( 1 ) );

      }

    }

    mTextArea.replaceSelection( newText );

  }

  /**

   * Delegates to {@link #autofix()}.

   *

   * @param event Ignored.

   */

  private void autofix( final KeyEvent event ) {

    autofix();

  }

  public void autofix() {

    final var caretWord = getCaretWord();

    final var textArea = getTextArea();

    final var word = textArea.getText( caretWord );

    final var suggestions = mSpeller.checkWord( word, 10 );

    if( suggestions.isEmpty() ) {

      clue( "Editor.spelling.check.matches.none", word );

    }

    else if( !suggestions.contains( word ) ) {

      final var menu = createSuggestionsPopup();

      final var items = menu.getItems();

      textArea.setContextMenu( menu );

      for( final var correction : suggestions ) {

        items.add( createSuggestedItem( caretWord, correction ) );

      }

      textArea.getCaretBounds().ifPresent(

        bounds -> menu.show(

          textArea, bounds.getCenterX(), bounds.getCenterY()

        )

      );

    }

    else {

      clue( "Editor.spelling.check.matches.okay", word );

    }

  }

  private ContextMenu createSuggestionsPopup() {

    final var menu = new ContextMenu();

    menu.setAutoHide( true );

    menu.setHideOnEscape( true );

    menu.setOnHidden( event -> getTextArea().setContextMenu( null ) );

    return menu;

  }

  /**

   * Creates a menu item capable of replacing a word under the cursor.

   *

   * @param i The beginning and ending text offset to replace.

   * @param s The text to replace at the given offset.

   * @return The menu item that, if actioned, will replace the text.

   */

  private MenuItem createSuggestedItem( final IndexRange i, final String s ) {

    final var menuItem = new MenuItem( s );

    menuItem.setOnAction( event -> getTextArea().replaceText( i, s ) );

    return menuItem;

  }

  private void cut( final KeyEvent event ) {

    cut();

  }

  private void tab( final KeyEvent event ) {

    final var range = mTextArea.selectionProperty().getValue();

    final var sb = new StringBuilder( 1024 );

    if( range.getLength() > 0 ) {

      final var selection = mTextArea.getSelectedText();

      selection.lines().forEach(

        ( l ) -> sb.append( "\t" ).append( l ).append( NEWLINE )

      );

    }

    else {

      sb.append( "\t" );

    }

    mTextArea.replaceSelection( sb.toString() );

  }

  private void untab( final KeyEvent event ) {

    final var range = mTextArea.selectionProperty().getValue();

    if( range.getLength() > 0 ) {

      final var selection = mTextArea.getSelectedText();

      final var sb = new StringBuilder( selection.length() );

      selection.lines().forEach(

        ( l ) -> sb.append( l.startsWith( "\t" ) ? l.substring( 1 ) : l )

                   .append( NEWLINE )

      );

      mTextArea.replaceSelection( sb.toString() );

    }

    else {

      final var p = getCaretParagraph();

      if( p.startsWith( "\t" ) ) {

        mTextArea.selectParagraph();

        mTextArea.replaceSelection( p.substring( 1 ) );

      }

    }

  }

  /**

   * Observers may listen for changes to the property returned from this method

   * to receive notifications when either the text or caret have changed. This

   * should not be used to track whether the text has been modified.

   */

  public void addDirtyListener( ChangeListener<Boolean> listener ) {

    mDirty.addListener( listener );

  }

  /**

   * Surrounds the selected text or word under the caret in Markdown markup.

   *

   * @param token The beginning and ending token for enclosing the text.

   */

  private void enwrap( final String token ) {

    enwrap( token, token );

  }

  /**

   * Surrounds the selected text or word under the caret in Markdown markup.

   *

   * @param began The beginning token for enclosing the text.

   * @param ended The ending token for enclosing the text.

   */

  private void enwrap( final String began, String ended ) {

    // Ensure selected text takes precedence over the word at caret position.

    final var selected = mTextArea.selectionProperty().getValue();

    final var range = selected.getLength() == 0

      ? getCaretWord()

      : selected;

    String text = mTextArea.getText( range );

    int length = range.getLength();

    text = stripStart( text, null );

    final int beganIndex = range.getStart() + (length - text.length());

    length = text.length();

    text = stripEnd( text, null );

    final int endedIndex = range.getEnd() - (length - text.length());

    mTextArea.replaceText( beganIndex, endedIndex, began + text + ended );

  }

  /**

   * Inserts the given block-level markup at the current caret position

   * within the document. This will prepend two blank lines to ensure that

   * the block element begins at the start of a new line.

   *

   * @param markup The text to insert at the caret.

   */

  private void block( final String markup ) {

    final int pos = mTextArea.getCaretPosition();

    mTextArea.insertText( pos, format( "%n%n%s", markup ) );

  }

  /**

   * Returns the caret position within the current paragraph.

   *

   * @return A value from 0 to the length of the current paragraph.

   */

  private int getCaretColumn() {

    return mTextArea.getCaretColumn();

  }

  @Override

  public IndexRange getCaretWord() {

    final var paragraph = getCaretParagraph()

      .replaceAll( "---", "   " )

      .replaceAll( "--", "  " )

      .replaceAll( "[\\[\\]{}()]", " " );

public final class FlyingSaucerPanel extends XHTMLPanel

  implements HtmlRenderer {

  public void scrollTo( final String id, final JScrollPane scrollPane ) {

    int y = max( box.getAbsY() - scrollPane.getVerticalScrollBar()

                                           .getHeight() / 2, 0 );

import io.gitlab.rxp90.jsymspell.Verbosity;

import io.gitlab.rxp90.jsymspell.api.SuggestItem;

import java.util.HashMap;

import java.util.Map;

import static io.gitlab.rxp90.jsymspell.Verbosity.ALL;

import static io.gitlab.rxp90.jsymspell.Verbosity.CLOSEST;

import static java.lang.Long.parseLong;

   * Creates a new spellchecker for a lexicon of words in the specified file.

  private static SpellChecker forLexicon( final Map<String, Long> lexicon ) {

    assert lexicon != null && !lexicon.isEmpty();

    try {

      return new SymSpellSpeller(

        new SymSpellBuilder()

          .setUnigramLexicon( lexicon )

          .build()

      );

    } catch( final Exception ex ) {

      clue( ex );

      return new PermissiveSpeller();

    }

   * interface is available.

  /**

   * This expensive operation is only called for viable words, not for

   * single punctuation characters or whitespace.

   *

   * @param lexeme The word to check for correctness.

   * @return {@code false} if the word is not in the lexicon.

   */

    assert lexeme != null;

    assert !lexeme.isBlank();

    final var words = lookup( lexeme, CLOSEST );

    return !words.isEmpty() && lexeme.equals( words.get( 0 ).getSuggestion() );

    final String text,

    final SpellCheckListener consumer ) {

  private static Map<String, Long> readLexicon( final String filename )

    final var map = new HashMap<String, Long>();

        String line;

        while( (line = reader.readLine()) != null ) {

          final String[] tokens = line.split( "\\t" );

          map.put( tokens[ 0 ], parseLong( tokens[ 1 ] ) );

        }

    return map;

    return !word.isBlank() && isLetter( word.charAt( 0 ) );

import java.util.List;

    mParser = Parser.builder().build();

            // Check current paragraph; the whole document was checked upon

            // opening.

            final var offset = change.getPosition();

            final var position = editor.offsetToPosition( offset, Forward );

            final var paraId = position.getMajor();

            final var paragraph = editor.getParagraph( paraId );

            final var text = paragraph.getText();

            // Prevent doubling-up styles.

            editor.clearStyle( paraId );

            spellcheck( editor, text, paraId );

          } );

  }

  /**

   * Returns a list of suggests for the given word. This is typically used to

   * check for suitable replacements of the word at the caret position.

   *

   * @param word  The word to spellcheck.

   * @param count The maximum number of suggested alternatives to return.

   * @return A list of recommended spellings for the given word.

   */

  public List<String> checkWord( final String word, final int count ) {

    return sSpellChecker.suggestions( word, count );

# Editor actions

# ########################################################################

Editor.spelling.check.matches.none=No suggestions for ''{0}'' found.

Editor.spelling.check.matches.okay=The spelling for ''{0}'' appears to be correct.

# ########################################################################

The lexicon files are retrieved from:

https://github.com/wolfgarbe/SymSpell/tree/master/SymSpell

The lexicons and bigrams are space-separated by default, but parsing a