Dave Jarvis' Repositories

* [OpenJDK 14](https://openjdk.java.net)

This section describes how to set up the development environment and

build native executables for supported operating systems.

1. Move `build-template` into `$HOME/bin`.

Version numbers are read directly from Git using a plugin. The version

number is written to `app.properties`, a properties file in the `resources`

directory that can be read from within the application.

    value: "42"

import com.keenwrite.service.Settings;

import com.keenwrite.util.ProtocolScheme;

import static java.lang.String.format;

public class AbstractFileFactory {

  private static final String MSG_UNKNOWN_FILE_TYPE =

      "Unknown type '%s' for file '%s'.";

  public FileType lookup( final Path path ) {

  protected FileType lookup( final Path path, final String prefix ) {

    final var settings = getSettings();

    final var keys = settings.getKeys( prefix );

      final var patterns = settings.getStringSettingList( key );

  }

  /**

   * Throws IllegalArgumentException because the given path could not be

   * recognized. This exists because

   *

   * @param type The detected path type (protocol, file extension, etc.).

   * @param path The path to a source of definitions.

   */

  protected void unknownFileType(

      final ProtocolScheme type, final String path ) {

    final String msg = format( MSG_UNKNOWN_FILE_TYPE, type, path );

    throw new IllegalArgumentException( msg );

  }

  /**

   * Return the singleton Settings instance.

   *

   * @return A non-null instance.

   */

  private Settings getSettings() {

    return SETTINGS;

import static com.keenwrite.StatusBarNotifier.alert;

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

      alert( ex );

      alert( ex );

    final String title = get( "Dialog.file.choose.open.title" );

    final FileChooser dialog = createFileChooser( title );

    final List<File> files = dialog.showOpenMultipleDialog( getWindow() );

    if( files != null ) {

      openFiles( files );

    }

  }

  /**

   * Opens the files into new editors, unless one of those files was a

   * definition file. The definition file is loaded into the definition pane,

   * but only the first one selected (multiple definition files will result in a

   * warning).

   *

   * @param files The list of non-definition files that the were requested to

   *              open.

   */

  private void openFiles( final List<File> files ) {

    final List<String> extensions =

        createExtensionFilter( DEFINITION ).getExtensions();

    final var predicate = createFileTypePredicate( extensions );

    // The user might have opened multiple definitions files. These will

    // be discarded from the text editable files.

    final var definitions

        = files.stream().filter( predicate ).collect( Collectors.toList() );

    // Create a modifiable list to remove any definition files that were

    // opened.

    final var editors = new ArrayList<>( files );

    if( !editors.isEmpty() ) {

      saveLastDirectory( editors.get( 0 ) );

    }

    editors.removeAll( definitions );

    // Open editor-friendly files (e.g,. Markdown, XML) in new tabs.

    if( !editors.isEmpty() ) {

      openEditors( editors, 0 );

    }

    if( !definitions.isEmpty() ) {

      openDefinition( definitions.get( 0 ) );

    }

  }

  private void openEditors( final List<File> files, final int activeIndex ) {

    final int fileTally = files.size();

    final List<Tab> tabs = getTabs();

    // Close single unmodified "Untitled" tab.

    if( tabs.size() == 1 ) {

      final FileEditorTab fileEditor = (FileEditorTab) (tabs.get( 0 ));

      if( fileEditor.getPath() == null && !fileEditor.isModified() ) {

        closeEditor( fileEditor, false );

      }

    }

    for( int i = 0; i < fileTally; i++ ) {

      final Path path = files.get( i ).toPath();

      FileEditorTab fileEditorTab = findEditor( path );

      // Only open new files.

      if( fileEditorTab == null ) {

        fileEditorTab = createFileEditor( path );

        getTabs().add( fileEditorTab );

      }

      // Select the first file in the list.

      if( i == activeIndex ) {

        getSelectionModel().select( fileEditorTab );

      }

    }

  }

  /**

   * Returns a property that changes when a new definition file is opened.

   *

   * @return The path to a definition file that was opened.

   */

  public ReadOnlyObjectProperty<Path> onOpenDefinitionFileProperty() {

    return getOnOpenDefinitionFile().getReadOnlyProperty();

  }

  private ReadOnlyObjectWrapper<Path> getOnOpenDefinitionFile() {

    return mOpenDefinition;

  }

  /**

   * Called when the user has opened a definition file (using the file open

   * dialog box). This will replace the current set of definitions for the

   * active tab.

   *

   * @param definition The file to open.

   */

  private void openDefinition( final File definition ) {

    // TODO: Prevent reading this file twice when a new text document is opened.

    // (might be a matter of checking the value first).

    getOnOpenDefinitionFile().set( definition.toPath() );

  }

  /**

   * Called when the contents of the editor are to be saved.

   *

   * @param tab The tab containing content to save.

   * @return true The contents were saved (or needn't be saved).

   */

  public boolean saveEditor( final FileEditorTab tab ) {

    if( tab == null || !tab.isModified() ) {

      return true;

    }

    return tab.getPath() == null ? saveEditorAs( tab ) : tab.save();

  }

  /**

   * Opens the Save As dialog for the user to save the content under a new

   * path.

   *

   * @param tab The tab with contents to save.

   * @return true The contents were saved, or the tab was null.

   */

  public boolean saveEditorAs( final FileEditorTab tab ) {

    if( tab == null ) {

      return true;

    }

    getSelectionModel().select( tab );

    final FileChooser fileChooser = createFileChooser( get(

        "Dialog.file.choose.save.title" ) );

    final File file = fileChooser.showSaveDialog( getWindow() );

    if( file == null ) {

      return false;

    }

    saveLastDirectory( file );

    tab.setPath( file.toPath() );

    return tab.save();

  }

  void saveAllEditors() {

    for( final FileEditorTab fileEditor : getAllEditors() ) {

      saveEditor( fileEditor );

    }

  }

  /**

   * Answers whether the file has had modifications. '

   *

   * @param tab THe tab to check for modifications.

   * @return false The file is unmodified.

   */

  @SuppressWarnings("BooleanMethodIsAlwaysInverted")

  boolean canCloseEditor( final FileEditorTab tab ) {

    final AtomicReference<Boolean> canClose = new AtomicReference<>();

    canClose.set( true );

    if( tab.isModified() ) {

      final Notification message = getNotifyService().createNotification(

          Messages.get( "Alert.file.close.title" ),

          Messages.get( "Alert.file.close.text" ),

          tab.getText()

      );

      final Alert confirmSave = getNotifyService().createConfirmation(

          getWindow(), message );

      final Optional<ButtonType> buttonType = confirmSave.showAndWait();

      buttonType.ifPresent(

          save -> canClose.set(

              save == YES ? saveEditor( tab ) : save == ButtonType.NO

          )

      );

    }

    return canClose.get();

  }

  boolean closeEditor( final FileEditorTab tab, final boolean save ) {

    if( tab == null ) {

      return true;

    }

    if( save ) {

      Event event = new Event( tab, tab, Tab.TAB_CLOSE_REQUEST_EVENT );

      Event.fireEvent( tab, event );

      if( event.isConsumed() ) {

        return false;

      }

    }

    getTabs().remove( tab );

    if( tab.getOnClosed() != null ) {

      Event.fireEvent( tab, new Event( Tab.CLOSED_EVENT ) );

    }

    return true;

  }

  boolean closeAllEditors() {

    final FileEditorTab[] allEditors = getAllEditors();

    final FileEditorTab activeEditor = getActiveFileEditor();

    // try to save active tab first because in case the user decides to cancel,

    // then it stays active

    if( activeEditor != null && !canCloseEditor( activeEditor ) ) {

      return false;

    }

    // This should be called any time a tab changes.

    persistPreferences();

    // save modified tabs

    for( int i = 0; i < allEditors.length; i++ ) {

      final FileEditorTab fileEditor = allEditors[ i ];

      if( fileEditor == activeEditor ) {

        continue;

      }

      if( fileEditor.isModified() ) {

        // activate the modified tab to make its modified content visible to

        // the user

        getSelectionModel().select( i );

        if( !canCloseEditor( fileEditor ) ) {

          return false;

        }

      }

    }

    // Close all tabs.

    for( final FileEditorTab fileEditor : allEditors ) {

      if( !closeEditor( fileEditor, false ) ) {

        return false;

      }

    }

    return getTabs().isEmpty();

  }

  private FileEditorTab[] getAllEditors() {

    final ObservableList<Tab> tabs = getTabs();

    final int length = tabs.size();

    final FileEditorTab[] allEditors = new FileEditorTab[ length ];

    for( int i = 0; i < length; i++ ) {

      allEditors[ i ] = (FileEditorTab) tabs.get( i );

    }

    return allEditors;

  }

  /**

   * Returns the file editor tab that has the given path.

   *

   * @return null No file editor tab for the given path was found.

   */

  private FileEditorTab findEditor( final Path path ) {

    for( final Tab tab : getTabs() ) {

      final FileEditorTab fileEditor = (FileEditorTab) tab;

      if( fileEditor.isPath( path ) ) {

        return fileEditor;

      }

    }

    return null;

  }

  private FileChooser createFileChooser( String title ) {

    final FileChooser fileChooser = new FileChooser();

    fileChooser.setTitle( title );

    fileChooser.getExtensionFilters().addAll(

        createExtensionFilters() );

    final String lastDirectory = getPreferences().get( "lastDirectory", null );

    File file = new File( (lastDirectory != null) ? lastDirectory : "." );

    if( !file.isDirectory() ) {

      file = new File( "." );

    }

    fileChooser.setInitialDirectory( file );

    return fileChooser;

  }

  private List<ExtensionFilter> createExtensionFilters() {

    final List<ExtensionFilter> list = new ArrayList<>();

    // TODO: Return a list of all properties that match the filter prefix.

    // This will allow dynamic filters to be added and removed just by

    // updating the properties file.

    list.add( createExtensionFilter( ALL ) );

    list.add( createExtensionFilter( SOURCE ) );

    list.add( createExtensionFilter( DEFINITION ) );

    list.add( createExtensionFilter( XML ) );

    return list;

  }

  /**

   * Returns a filter for file name extensions recognized by the application

   * that can be opened by the user.

   *

   * @param filetype Used to find the globbing pattern for extensions.

   * @return A filename filter suitable for use by a FileDialog instance.

   */

  private ExtensionFilter createExtensionFilter( final FileType filetype ) {

    final String tKey = String.format( "%s.title.%s",

                                       FILTER_EXTENSION_TITLES,

                                       filetype );

    final String eKey = String.format( "%s.%s", GLOB_PREFIX_FILE, filetype );

    return new ExtensionFilter( Messages.get( tKey ), getExtensions( eKey ) );

  }

  private void saveLastDirectory( final File file ) {

    getPreferences().put( "lastDirectory", file.getParent() );

  }

  public void initPreferences() {

    int activeIndex = 0;

    final Preferences preferences = getPreferences();

    final String[] fileNames = Utils.getPrefsStrings( preferences, "file" );

    final String activeFileName = preferences.get( "activeFile", null );

    final List<File> files = new ArrayList<>( fileNames.length );

    for( final String fileName : fileNames ) {

      final File file = new File( fileName );

      if( file.exists() ) {

        files.add( file );

        if( fileName.equals( activeFileName ) ) {

          activeIndex = files.size() - 1;

        }

      }

    }

    if( files.isEmpty() ) {

      newEditor();

    }

    else {

      openEditors( files, activeIndex );

    }

  }

  public void persistPreferences() {

    final var allEditors = getTabs();

    final List<String> fileNames = new ArrayList<>( allEditors.size() );

    for( final var tab : allEditors ) {

      final var fileEditor = (FileEditorTab) tab;

      final var filePath = fileEditor.getPath();

      if( filePath != null ) {

        fileNames.add( filePath.toString() );

      }

    }

    final var preferences = getPreferences();

    Utils.putPrefsStrings( preferences,

                           "file",

                           fileNames.toArray( new String[ 0 ] ) );

    final var activeEditor = getActiveFileEditor();

    final var filePath = activeEditor == null ? null : activeEditor.getPath();

    if( filePath == null ) {

      preferences.remove( "activeFile" );

    }

    else {

      preferences.put( "activeFile", filePath.toString() );

    }

  }

  private List<String> getExtensions( final String key ) {

    return getSettings().getStringSettingList( key );

  }

  private Notifier getNotifyService() {

    return sNotifier;

  }

  private Settings getSettings() {

    return SETTINGS;

  }

  protected Options getOptions() {

    return sOptions;

  }

  private Window getWindow() {

    return getScene().getWindow();

  }

  private Preferences getPreferences() {

    return getOptions().getState();

import static com.keenwrite.StatusBarNotifier.alert;

              alert( e );

      alert( e );

import com.keenwrite.preferences.UserPreferences;

import com.keenwrite.preview.HTMLPreviewPane;

import com.keenwrite.exceptions.MissingFileException;

import com.keenwrite.processors.HtmlPreviewProcessor;

import com.keenwrite.processors.Processor;

import com.keenwrite.processors.ProcessorFactory;

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.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.Clipboard;

import javafx.scene.input.ClipboardContent;

import javafx.scene.input.KeyEvent;

import javafx.scene.layout.BorderPane;

import javafx.scene.layout.VBox;

import javafx.scene.text.Text;

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.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.Messages.get;

import static com.keenwrite.StatusBarNotifier.alert;

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.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.

   */

  private void addShowListener(

      final Node node, final Consumer<Void> consumer ) {

    final ChangeListener<? super Boolean> listener = ( o, oldShow, newShow ) ->

        runLater( () -> {

          if( newShow != null && newShow ) {

            try {

              consumer.accept( null );

            } catch( final Exception ex ) {

              alert( ex );

            }

          }

        } );

    Val.flatMap( node.sceneProperty(), Scene::windowProperty )

       .flatMap( Window::showingProperty )

       .addListener( listener );

  }

  private void scrollToParagraph( final int id ) {

    scrollToParagraph( id, false );

  }

  /**

   * @param id    The paragraph to scroll to, will be approximated if it doesn't

   *              exist.