Dave Jarvis' Repositories

  <component name="JavacSettings">

    <option name="ADDITIONAL_OPTIONS_OVERRIDE">

      <module name="scrivenvar.main" options="--add-exports java.desktop/sun.swing=ALL-UNNAMED" />

    </option>

  </component>

  id 'org.beryx.jlink' version '2.16.2'

  implementation 'com.vladsch.flexmark:flexmark:0.62.2'

  implementation 'com.vladsch.flexmark:flexmark-ext-definition:0.62.2'

  implementation 'com.vladsch.flexmark:flexmark-ext-gfm-strikethrough:0.62.2'

  implementation 'com.vladsch.flexmark:flexmark-ext-superscript:0.62.2'

  implementation 'com.vladsch.flexmark:flexmark-ext-tables:0.62.2'

  implementation 'com.vladsch.flexmark:flexmark-ext-typographic:0.62.2'

  implementation 'com.fasterxml.jackson.core:jackson-core:2.11.2'

  implementation 'com.fasterxml.jackson.core:jackson-databind:2.11.2'

  implementation 'com.fasterxml.jackson.core:jackson-annotations:2.11.2'

  implementation 'com.fasterxml.jackson.dataformat:jackson-dataformat-yaml:2.11.2'

  implementation 'org.apache.xmlgraphics:batik-anim:1.13'

  implementation 'org.apache.xmlgraphics:batik-awt-util:1.13'

  implementation 'org.apache.xmlgraphics:batik-bridge:1.13'

  implementation 'org.apache.xmlgraphics:batik-css:1.13'

  implementation 'org.apache.xmlgraphics:batik-dom:1.13'

  implementation 'org.apache.xmlgraphics:batik-ext:1.13'

  implementation 'org.apache.xmlgraphics:batik-gvt:1.13'

  implementation 'org.apache.xmlgraphics:batik-parser:1.13'

  implementation 'org.apache.xmlgraphics:batik-script:1.13'

  implementation 'org.apache.xmlgraphics:batik-svg-dom:1.13'

  implementation 'org.apache.xmlgraphics:batik-svggen:1.13'

  implementation 'org.apache.xmlgraphics:batik-transcoder:1.13'

  implementation 'org.apache.xmlgraphics:batik-util:1.13'

  implementation 'org.apache.xmlgraphics:batik-xml:1.13'

  testImplementation('org.junit.jupiter:junit-jupiter-api:5.4.2')

  testRuntime('org.junit.jupiter:junit-jupiter-engine:5.4.2')

* [texample.md](texample.md) -- Numerous examples of formulas

Variables can reference other variables by enclosing the key name within dollar symbols:

key_1: $key$ 1

key_2: $key$ 2

  owner: $novel.author$

  title: Diary of $novel.author$

To reference a variable, type in the key name enclosed within dollar symbols, such as:

The novel "$novel.title$" is one of the most widely read books in the world.

$novel.title$

    setwd( '$application.r.working.directory$' );

Calling `setwd` using `'$application.r.working.directory$'` changes the

   * Default starting delimiter for definition variables.

  public static final String DEF_DELIM_BEGAN_DEFAULT = "${";

  public static final String DEF_DELIM_ENDED_DEFAULT = "}";

  /**

   * Used as the prefix for uniquely identifying HTML block elements, which

   * helps coordinate scrolling the preview pane to where the user is typing.

   */

  public static final String PARAGRAPH_ID_PREFIX = "p-";

  private ExportFormat( final String extension ) {

  }

  public boolean isHtml() {

    return this == HTML_TEX_SVG || this == HTML_TEX_DELIMITED;

  }

  public boolean isMarkdown() {

    return this == MARKDOWN_PLAIN;

import com.keenwrite.service.events.Notification;

import com.keenwrite.service.events.Notifier;

import javafx.beans.binding.Bindings;

import javafx.beans.property.BooleanProperty;

import javafx.beans.property.ReadOnlyBooleanProperty;

import javafx.beans.property.ReadOnlyBooleanWrapper;

import javafx.beans.property.SimpleBooleanProperty;

import javafx.beans.value.ChangeListener;

import javafx.event.Event;

import javafx.event.EventHandler;

import javafx.event.EventType;

import javafx.scene.Scene;

import javafx.scene.control.Tab;

import javafx.scene.control.Tooltip;

import javafx.scene.text.Text;

import javafx.stage.Window;

import org.fxmisc.flowless.VirtualizedScrollPane;

import org.fxmisc.richtext.StyleClassedTextArea;

import org.fxmisc.undo.UndoManager;

import org.jetbrains.annotations.NotNull;

import org.mozilla.universalchardet.UniversalDetector;

import java.io.File;

import java.nio.charset.Charset;

import java.nio.file.Files;

import java.nio.file.Path;

import static com.keenwrite.Messages.get;

import static com.keenwrite.StatusBarNotifier.clue;

import static com.keenwrite.StatusBarNotifier.getNotifier;

import static java.nio.charset.StandardCharsets.UTF_8;

import static java.util.Locale.ENGLISH;

import static javafx.application.Platform.runLater;

/**

 * Editor for a single file.

 */

public final class FileEditorTab extends Tab {

  private final MarkdownEditorPane mEditorPane = new MarkdownEditorPane();

  private final ReadOnlyBooleanWrapper mModified = new ReadOnlyBooleanWrapper();

  private final BooleanProperty canUndo = new SimpleBooleanProperty();

  private final BooleanProperty canRedo = new SimpleBooleanProperty();

  /**

   * Character encoding used by the file (or default encoding if none found).

   */

  private Charset mEncoding = UTF_8;

  /**

   * File to load into the editor.

   */

  private Path mPath;

  public FileEditorTab( final Path path ) {

    setPath( path );

    mModified.addListener( ( observable, oldPath, newPath ) -> updateTab() );

    setOnSelectionChanged( e -> {

      if( isSelected() ) {

        runLater( this::activated );

        requestFocus();

      }

    } );

  }

  private void updateTab() {

    setText( getTabTitle() );

    setGraphic( getModifiedMark() );

    setTooltip( getTabTooltip() );

  }

  /**

   * Returns the base filename (without the directory names).

   *

   * @return The untitled text if the path hasn't been set.

   */

  private String getTabTitle() {

    return getPath().getFileName().toString();

  }

  /**

   * Returns the full filename represented by the path.

   *

   * @return The untitled text if the path hasn't been set.

   */

  private Tooltip getTabTooltip() {

    final Path filePath = getPath();

    return new Tooltip( filePath == null ? "" : filePath.toString() );

  }

  /**

   * Returns a marker to indicate whether the file has been modified.

   *

   * @return "*" when the file has changed; otherwise null.

   */

  private Text getModifiedMark() {

    return isModified() ? new Text( "*" ) : null;

  }

  /**

   * Called when the user switches tab.

   */

  private void activated() {

    // Tab is closed or no longer active.

    if( getTabPane() == null || !isSelected() ) {

      return;

    }

    // If the tab is devoid of content, load it.

    if( getContent() == null ) {

      readFile();

      initLayout();

      initUndoManager();

    }

  }

  private void initLayout() {

    setContent( getScrollPane() );

  }

  /**

   * Tracks undo requests, but can only be called <em>after</em> load.

   */

  private void initUndoManager() {

    final UndoManager<?> undoManager = getUndoManager();

    undoManager.forgetHistory();

    // Bind the editor undo manager to the properties.

    mModified.bind( Bindings.not( undoManager.atMarkedPositionProperty() ) );

    canUndo.bind( undoManager.undoAvailableProperty() );

    canRedo.bind( undoManager.redoAvailableProperty() );

  }

  private void requestFocus() {

    getEditorPane().requestFocus();

  }

  /**

   * Searches from the caret position forward for the given string.

   *

   * @param needle The text string to match.

   */

  public void searchNext( final String needle ) {

    final String haystack = getEditorText();

    int index = haystack.indexOf( needle, getCaretPosition() );

    // Wrap around.

    if( index == -1 ) {

      index = haystack.indexOf( needle );

    }

    if( index >= 0 ) {

      setCaretPosition( index );

      getEditor().selectRange( index, index + needle.length() );

    }

  }

  /**

   * Gets a reference to the scroll pane that houses the editor.

   *

   * @return The editor's scroll pane, containing a vertical scrollbar.

   */

  public VirtualizedScrollPane<StyleClassedTextArea> getScrollPane() {

    return getEditorPane().getScrollPane();

  }

  /**

   * Returns the index into the text where the caret blinks happily away.

   *

   * @return A number from 0 to the editor's document text length.

   */

  public int getCaretPosition() {

    return getEditor().getCaretPosition();

  }

  /**

   * Moves the caret to a given offset.

   *

   * @param offset The new caret offset.

   */

  private void setCaretPosition( final int offset ) {

    getEditor().moveTo( offset );

    getEditor().requestFollowCaret();

  }

  /**

   * Returns the text area associated with this tab.

   *

   * @return A text editor.

   */

  private StyleClassedTextArea getEditor() {

    return getEditorPane().getEditor();

  }

  /**

   * Returns true if the given path exactly matches this tab's path.

   *

   * @param check The path to compare against.

   * @return true The paths are the same.

   */

  public boolean isPath( final Path check ) {

    final Path filePath = getPath();

    return filePath != null && filePath.equals( check );

  }

  /**

   * Reads the entire file contents from the path associated with this tab.

   */

  private void readFile() {

    final Path path = getPath();

    final File file = path.toFile();

    try {

      if( file.exists() ) {

        if( file.canWrite() && file.canRead() ) {

          final EditorPane pane = getEditorPane();

          pane.setText( asString( Files.readAllBytes( path ) ) );

          pane.scrollToTop();

        }

        else {

          final String msg = get( "FileEditor.loadFailed.reason.permissions" );

          clue( "FileEditor.loadFailed.message", file.toString(), msg );

        }

      }

    } catch( final Exception ex ) {

      clue( ex );

    }

  }

  /**

   * Saves the entire file contents from the path associated with this tab.

   *

   * @return true The file has been saved.

   */

  public boolean save() {

    try {

      final EditorPane editor = getEditorPane();

      Files.write( getPath(), asBytes( editor.getText() ) );

      editor.getUndoManager().mark();

      return true;

    } catch( final Exception ex ) {

      return popupAlert(

          "FileEditor.saveFailed.title",

          "FileEditor.saveFailed.message",

          ex

      );

    }

  }

  /**

   * Creates an alert dialog and waits for it to close.

   *

   * @param titleKey   Resource bundle key for the alert dialog title.

   * @param messageKey Resource bundle key for the alert dialog message.

   * @param e          The unexpected happening.

   * @return false

   */

  @SuppressWarnings("SameParameterValue")

  private boolean popupAlert(

      final String titleKey, final String messageKey, final Exception e ) {

    final Notifier service = getNotifier();

    final Path filePath = getPath();

    final Notification message = service.createNotification(

        get( titleKey ),

        get( messageKey ),

        filePath == null ? "" : filePath,

        e.getMessage()

    );

    try {

      service.createError( getWindow(), message ).showAndWait();

    } catch( final Exception ex ) {

      clue( ex );

    }

    return false;

  }

  private Window getWindow() {

    final Scene scene = getEditorPane().getScene();

    if( scene == null ) {

      throw new UnsupportedOperationException( "No scene window available" );

    }

    return scene.getWindow();

  }

  /**

   * Returns a best guess at the file encoding. If the encoding could not be

   * detected, this will return the default charset for the JVM.

   *

   * @param bytes The bytes to perform character encoding detection.

   * @return The character encoding.

   */

  private Charset detectEncoding( final byte[] bytes ) {

    final var detector = new UniversalDetector( null );

    detector.handleData( bytes, 0, bytes.length );

    detector.dataEnd();

    final String charset = detector.getDetectedCharset();

    return charset == null

        ? Charset.defaultCharset()

        : Charset.forName( charset.toUpperCase( ENGLISH ) );

  }

  /**

   * Converts the given string to an array of bytes using the encoding that was

   * originally detected (if any) and associated with this file.

   *

   * @param text The text to convert into the original file encoding.

   * @return A series of bytes ready for writing to a file.

   */

  private byte[] asBytes( final String text ) {

    return text.getBytes( getEncoding() );

  }

  /**

   * Converts the given bytes into a Java String. This will call setEncoding

   * with the encoding detected by the CharsetDetector.

   *

   * @param text The text of unknown character encoding.

   * @return The text, in its auto-detected encoding, as a String.

   */

  private String asString( final byte[] text ) {

    setEncoding( detectEncoding( text ) );

    return new String( text, getEncoding() );

  }

  /**

   * Returns the path to the file being edited in this tab.

   *

   * @return A non-null instance.

   */

  public Path getPath() {

    return mPath;

  }

  /**

   * Sets the path to a file for editing and then updates the tab with the

   * file contents.

   *

   * @param path A non-null instance.

   */

  public void setPath( final Path path ) {

    assert path != null;

    mPath = path;

    updateTab();

  }

  public boolean isModified() {

    return mModified.get();

  }

  ReadOnlyBooleanProperty modifiedProperty() {

    return mModified.getReadOnlyProperty();

  }

  BooleanProperty canUndoProperty() {

    return this.canUndo;

  }

  BooleanProperty canRedoProperty() {

    return this.canRedo;

  }

  private UndoManager<?> getUndoManager() {

    return getEditorPane().getUndoManager();

  }

  /**

   * Forwards to the editor pane's listeners for text change events.

   *

   * @param listener The listener to notify when the text changes.

   */

  public void addTextChangeListener( final ChangeListener<String> listener ) {

    getEditorPane().addTextChangeListener( listener );

  }

  /**

   * Forwards to the editor pane's listeners for caret change events.

   *

   * @param listener Notified when the caret position changes.

   */

  public void addCaretPositionListener(

      final ChangeListener<? super Integer> listener ) {

    getEditorPane().addCaretPositionListener( listener );

  }

  /**

   * Forwards to the editor pane's listeners for paragraph index change events.

   *

   * @param listener Notified when the caret's paragraph index changes.

   */

  public void addCaretParagraphListener(

      final ChangeListener<? super Integer> listener ) {

    getEditorPane().addCaretParagraphListener( listener );

  private final ChangeListener<Integer> mCaretParagraphListener;

   * @param caretParagraphListener Listens for changes to the caret's paragraph

   *                               so that scrolling may occur.

      final ChangeListener<Integer> caretPositionListener,

      final ChangeListener<Integer> caretParagraphListener ) {

    mCaretParagraphListener = caretParagraphListener;

    tab.addCaretParagraphListener( mCaretParagraphListener );

import com.keenwrite.editors.EditorPane;

import com.keenwrite.editors.markdown.MarkdownEditorPane;

import com.keenwrite.exceptions.MissingFileException;

import com.keenwrite.preferences.UserPreferences;

import com.keenwrite.preview.HTMLPreviewPane;

import com.keenwrite.processors.Processor;

import com.keenwrite.processors.ProcessorContext;

import com.keenwrite.processors.ProcessorFactory;

import com.keenwrite.processors.markdown.MarkdownProcessor;

import com.keenwrite.service.Options;

import com.keenwrite.service.Snitch;

import com.keenwrite.spelling.api.SpellCheckListener;

import com.keenwrite.spelling.api.SpellChecker;

import com.keenwrite.spelling.impl.PermissiveSpeller;

import com.keenwrite.spelling.impl.SymSpellSpeller;

import com.keenwrite.util.Action;

import com.keenwrite.util.ActionBuilder;

import com.keenwrite.util.ActionUtils;

import com.keenwrite.util.SeparatorAction;

import com.vladsch.flexmark.parser.Parser;

import com.vladsch.flexmark.util.ast.NodeVisitor;

import com.vladsch.flexmark.util.ast.VisitHandler;

import javafx.beans.binding.Bindings;

import javafx.beans.binding.BooleanBinding;

import javafx.beans.property.BooleanProperty;

import javafx.beans.property.SimpleBooleanProperty;

import javafx.beans.value.ChangeListener;

import javafx.beans.value.ObservableBooleanValue;

import javafx.beans.value.ObservableValue;

import javafx.collections.ListChangeListener.Change;

import javafx.collections.ObservableList;

import javafx.event.Event;

import javafx.event.EventHandler;

import javafx.geometry.Pos;

import javafx.scene.Node;

import javafx.scene.Scene;

import javafx.scene.control.*;

import javafx.scene.image.ImageView;

import javafx.scene.input.KeyEvent;

import javafx.scene.layout.BorderPane;

import javafx.scene.layout.VBox;

import javafx.scene.text.Text;

import javafx.stage.FileChooser;

import javafx.stage.Window;

import javafx.stage.WindowEvent;

import javafx.util.Duration;

import org.apache.commons.lang3.SystemUtils;

import org.controlsfx.control.StatusBar;

import org.fxmisc.richtext.StyleClassedTextArea;

import org.fxmisc.richtext.model.StyleSpansBuilder;

import org.reactfx.value.Val;

import java.io.BufferedReader;

import java.io.File;

import java.io.IOException;

import java.io.InputStreamReader;

import java.nio.file.Path;

import java.util.*;

import java.util.concurrent.atomic.AtomicInteger;

import java.util.function.Consumer;

import java.util.function.Function;

import java.util.prefs.Preferences;

import java.util.stream.Collectors;

import static com.keenwrite.Bootstrap.APP_TITLE;

import static com.keenwrite.Constants.*;

import static com.keenwrite.ExportFormat.*;

import static com.keenwrite.Messages.get;

import static com.keenwrite.StatusBarNotifier.clue;

import static com.keenwrite.processors.ProcessorFactory.processChain;

import static com.keenwrite.util.StageState.*;

import static de.jensd.fx.glyphs.fontawesome.FontAwesomeIcon.*;

import static java.nio.charset.StandardCharsets.UTF_8;

import static java.nio.file.Files.writeString;

import static java.util.Collections.emptyList;

import static java.util.Collections.singleton;

import static javafx.application.Platform.runLater;

import static javafx.event.Event.fireEvent;

import static javafx.scene.control.Alert.AlertType.INFORMATION;

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

import static javafx.stage.WindowEvent.WINDOW_CLOSE_REQUEST;

import static org.fxmisc.richtext.model.TwoDimensional.Bias.Forward;

/**

 * Main window containing a tab pane in the center for file editors.

 */

public class MainWindow implements Observer {

  /**

   * The {@code OPTIONS} variable must be declared before all other variables

   * to prevent subsequent initializations from failing due to missing user

   * preferences.

   */

  private static final Options sOptions = Services.load( Options.class );

  private static final Snitch SNITCH = Services.load( Snitch.class );

  private final Scene mScene;

  private final StatusBar mStatusBar;

  private final Text mLineNumberText;

  private final TextField mFindTextField;

  private final SpellChecker mSpellChecker;

  private final Object mMutex = new Object();

  /**

   * Prevents re-instantiation of processing classes.

   */

  private final Map<FileEditorTab, Processor<String>> mProcessors =

      new HashMap<>();

  private final Map<String, String> mResolvedMap =

      new HashMap<>( DEFAULT_MAP_SIZE );

  private final EventHandler<PreferencesFxEvent> mRPreferencesListener =

      event -> rerender();

  /**

   * Called when the definition data is changed.

   */

  private final EventHandler<TreeItem.TreeModificationEvent<Event>>

      mTreeHandler = event -> {

    exportDefinitions( getDefinitionPath() );

    interpolateResolvedMap();

    rerender();

  };

  /**

   * Called to inject the selected item when the user presses ENTER in the

   * definition pane.

   */

  private final EventHandler<? super KeyEvent> mDefinitionKeyHandler =

      event -> {

        if( event.getCode() == ENTER ) {

          getDefinitionNameInjector().injectSelectedItem();

        }

      };

  private final ChangeListener<Integer> mCaretPositionListener =

      ( observable, oldPosition, newPosition ) -> {

        final FileEditorTab tab = getActiveFileEditorTab();

        final EditorPane pane = tab.getEditorPane();

        final StyleClassedTextArea editor = pane.getEditor();

        getLineNumberText().setText(

            get( STATUS_BAR_LINE,

                 editor.getCurrentParagraph() + 1,

                 editor.getParagraphs().size(),

                 editor.getCaretPosition()

            )

        );

      };

  private final ChangeListener<Integer> mCaretParagraphListener =

      ( observable, oldIndex, newIndex ) ->

          scrollToParagraph( newIndex, true );

  private DefinitionSource mDefinitionSource = createDefaultDefinitionSource();

  private final DefinitionPane mDefinitionPane = createDefinitionPane();

  private final HTMLPreviewPane mPreviewPane = createHTMLPreviewPane();

  private final FileEditorTabPane mFileEditorPane = new FileEditorTabPane(

      mCaretPositionListener,

      mCaretParagraphListener );

  /**

   * Listens on the definition pane for double-click events.

   */

  private final DefinitionNameInjector mDefinitionNameInjector

      = new DefinitionNameInjector( mDefinitionPane );

  public MainWindow() {

    mStatusBar = createStatusBar();

    mLineNumberText = createLineNumberText();

    mFindTextField = createFindTextField();

    mScene = createScene();

    mSpellChecker = createSpellChecker();

    // Add the close request listener before the window is shown.

    initLayout();

    StatusBarNotifier.setStatusBar( mStatusBar );

  }

  /**

   * Called after the stage is shown.

   */

  public void init() {

    initFindInput();

    initSnitch();

    initDefinitionListener();

    initTabAddedListener();

    initTabChangedListener();

    initPreferences();

    initVariableNameInjector();

  }

  private void initLayout() {

    final var scene = getScene();

    scene.getStylesheets().add( STYLESHEET_SCENE );

    scene.windowProperty().addListener(

        ( unused, oldWindow, newWindow ) ->

            newWindow.setOnCloseRequest(

                e -> {

                  if( !getFileEditorPane().closeAllEditors() ) {

                    e.consume();

                  }

                }

            )

    );

  }

  /**

   * Initialize the find input text field to listen on F3, ENTER, and

   * ESCAPE key presses.

   */

  private void initFindInput() {

    final TextField input = getFindTextField();

    input.setOnKeyPressed( ( KeyEvent event ) -> {

      switch( event.getCode() ) {

        case F3:

        case ENTER:

          editFindNext();

          break;

        case F:

          if( !event.isControlDown() ) {

            break;

          }

        case ESCAPE:

          getStatusBar().setGraphic( null );

          getActiveFileEditorTab().getEditorPane().requestFocus();

          break;

      }

    } );

    // Remove when the input field loses focus.

    input.focusedProperty().addListener(

        ( focused, oldFocus, newFocus ) -> {

          if( !newFocus ) {

            getStatusBar().setGraphic( null );

          }

        }

    );

  }

  /**

   * Watch for changes to external files. In particular, this awaits

   * modifications to any XSL files associated with XML files being edited.

   * When

   * an XSL file is modified (external to the application), the snitch's ears

   * perk up and the file is reloaded. This keeps the XSL transformation up to

   * date with what's on the file system.

   */

  private void initSnitch() {

    SNITCH.addObserver( this );

  }

  /**

   * Listen for {@link FileEditorTabPane} to receive open definition file

   * event.

   */

  private void initDefinitionListener() {

    getFileEditorPane().onOpenDefinitionFileProperty().addListener(

        ( final ObservableValue<? extends Path> file,

          final Path oldPath, final Path newPath ) -> {

          openDefinitions( newPath );

          rerender();

        }

    );

  }

  /**

   * Re-instantiates all processors then re-renders the active tab. This

   * will refresh the resolved map, force R to re-initialize, and brute-force

   * XSLT file reloads.

   */

  private void rerender() {

    runLater(

        () -> {

          resetProcessors();

          renderActiveTab();

        }

    );

  }

  /**

   * When tabs are added, hook the various change listeners onto the new

   * tab sothat the preview pane refreshes as necessary.

   */

  private void initTabAddedListener() {

    final FileEditorTabPane editorPane = getFileEditorPane();

    // Make sure the text processor kicks off when new files are opened.

    final ObservableList<Tab> tabs = editorPane.getTabs();

    // Update the preview pane on tab changes.

    tabs.addListener(

        ( final Change<? extends Tab> change ) -> {

          while( change.next() ) {

            if( change.wasAdded() ) {

              // Multiple tabs can be added simultaneously.

              for( final Tab newTab : change.getAddedSubList() ) {

                final FileEditorTab tab = (FileEditorTab) newTab;

                initTextChangeListener( tab );

                initScrollEventListener( tab );

                initSpellCheckListener( tab );

//              initSyntaxListener( tab );

              }

            }

          }

        }

    );

  }

  private void initTextChangeListener( final FileEditorTab tab ) {

    tab.addTextChangeListener(

        ( __, ov, nv ) -> {

          process( tab );

          scrollToParagraph( getCurrentParagraphIndex() );

        }

    );

  }

  private void initScrollEventListener( final FileEditorTab tab ) {

    final var scrollPane = tab.getScrollPane();

    final var scrollBar = getPreviewPane().getVerticalScrollBar();

    addShowListener( scrollPane, ( __ ) -> {

      final var handler = new ScrollEventHandler( scrollPane, scrollBar );

      handler.enabledProperty().bind( tab.selectedProperty() );

    } );

  }

  /**

   * Listen for changes to the any particular paragraph and perform a quick

   * spell check upon it. The style classes in the editor will be changed to

   * mark any spelling mistakes in the paragraph. The user may then interact

   * with any misspelled word (i.e., any piece of text that is marked) to

   * revise the spelling.

   *

   * @param tab The tab to spellcheck.

   */

  private void initSpellCheckListener( final FileEditorTab tab ) {

    final var editor = tab.getEditorPane().getEditor();

    // When the editor first appears, run a full spell check. This allows

    // spell checking while typing to be restricted to the active paragraph,

    // which is usually substantially smaller than the whole document.

    addShowListener(

        editor, ( __ ) -> spellcheck( editor, editor.getText() )

    );

    // Use the plain text changes so that notifications of style changes

    // are suppressed. Checking against the identity ensures that only

    // new text additions or deletions trigger proofreading.

    editor.plainTextChanges()

          .filter( p -> !p.isIdentity() ).subscribe( change -> {

      // Only perform a spell check on the current paragraph. The

      // entire document is processed once, when opened.

      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();

      // Ensure that styles aren't doubled-up.

      editor.clearStyle( paraId );

      spellcheck( editor, text, paraId );

    } );

  }

  /**

   * Listen for new tab selection events.

   */

  private void initTabChangedListener() {

    final FileEditorTabPane editorPane = getFileEditorPane();

    // Update the preview pane changing tabs.

    editorPane.addTabSelectionListener(

        ( tabPane, oldTab, newTab ) -> {

          if( newTab == null ) {

            // Clear the preview pane when closing an editor. When the last

            // tab is closed, this ensures that the preview pane is empty.

            getPreviewPane().clear();

          }

          else {

            final var tab = (FileEditorTab) newTab;

            updateVariableNameInjector( tab );

            process( tab );

          }

        }

    );

  }

  /**

   * Reloads the preferences from the previous session.

   */

  private void initPreferences() {

    initDefinitionPane();

    getFileEditorPane().initPreferences();

    getUserPreferences().addSaveEventHandler( mRPreferencesListener );

  }

  private void initVariableNameInjector() {

    updateVariableNameInjector( getActiveFileEditorTab() );

  }

  /**

   * Calls the listener when the given node is shown for the first time. The

   * visible property is not the same as the initial showing event; visibility

   * can be triggered numerous times (such as going off screen).

   * <p>

   * This is called, for example, before the drag handler can be attached,

   * because the scrollbar for the text editor pane must be visible.

   * </p>

   *

   * @param node     The node to watch for showing.

   * @param consumer The consumer to invoke when the event fires.

   */