Dave Jarvis' Repositories

csv2md <- function( f, decimals = 2, totals = T, align = T ) {

      collapse = '|\n', sep=''

    '|\n',

ARG_JAVA_VERSION="17"

ARG_JAVA_UPDATE="35"

"\${SCRIPT_SRC}/${ARG_JAVA_DIR}/bin/java" ${OPT_JAVA} -jar "\${SCRIPT_SRC}/${FILE_APP_JAR}" "\$@" 2>/dev/null &

/* Copyright 2020-2021 White Magic Software, Ltd. -- All rights reserved. */

package com.keenwrite;

import com.keenwrite.io.FileType;

import java.nio.file.Path;

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

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

import static com.keenwrite.io.FileType.UNKNOWN;

import static com.keenwrite.predicates.PredicateFactory.createFileTypePredicate;

/**

 * Provides common behaviours for factories that instantiate classes based on

 * file type.

 */

public abstract class AbstractFileFactory {

  /**

   * Determines the file type from the path extension. This should only be

   * called when it is known that the file type won't be a definition file

   * (e.g., YAML or other definition source), but rather an editable file

   * (e.g., Markdown, R Markdown, etc.).

   *

   * @param path The path with a file name extension.

   * @return The FileType for the given path.

   */

  public static FileType lookup( final Path path ) {

    assert path != null;

    return lookup( path, GLOB_PREFIX_FILE );

  }

  /**

   * Creates a file type that corresponds to the given path.

   *

   * @param path   Reference to a variable definition file.

   * @param prefix One of GLOB_PREFIX_DEFINITION or GLOB_PREFIX_FILE.

   * @return The file type that corresponds to the given path.

   */

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

    assert path != null;

    assert prefix != null;

    final var keys = sSettings.getKeys( prefix );

    var found = false;

    var fileType = UNKNOWN;

    while( keys.hasNext() && !found ) {

      final var key = keys.next();

      final var patterns = sSettings.getStringSettingList( key );

      final var predicate = createFileTypePredicate( patterns );

      if( predicate.test( path.toFile() ) ) {

        // Remove the EXTENSIONS_PREFIX to get the file name extension mapped

        // to a standard name (as defined in the settings.properties file).

        final String suffix = key.replace( prefix + '.', "" );

        fileType = FileType.from( suffix );

        found = true;

      }

    }

    return fileType;

  }

}

import com.keenwrite.processors.ProcessorContext;

import com.keenwrite.typesetting.Typesetter;

import com.keenwrite.ui.dialogs.ThemePicker;

import static com.keenwrite.ExportFormat.*;

    final var context = args.createProcessorContext();

   * @param inputPath The source document to export in the given file format.

   * @param format    The destination file format.

   * @param concat    Export all files in the actively edited file's directory.

   * @param future    Indicates whether the export succeeded or failed.

  private void file_export(

    final Path inputPath,

    final ExportFormat format,

    final boolean concat,

    final CompletableFuture<Path> future ) {

        final var context = ProcessorContext.create( inputPath, format );

        final var outputPath = format.toExportPath( inputPath );

        future.complete( result );

      } catch( final Exception ex ) {

  }

  /**

   * @param concat {@code true} means to export all files in the active file

   *               editor's directory; {@code false} means to export only the

   *               actively edited file.

   *

  private void file_export_pdf( final Path theme, final boolean concat ) {

    if( Typesetter.canRun() ) {

      // If the typesetter is installed, allow the user to select a theme. If

      // the themes aren't installed, a status message will appear.

      if( ThemePicker.choose( themes, theme ) ) {

        file_export( APPLICATION_PDF, concat );

      }

    }

    else {

      fireExportFailedEvent();

    }

  }

  public void file_export_pdf() {

    file_export_pdf( false );

  }

  public void file_export_pdf_dir() {

    file_export_pdf( true );

  }

  public void file_export_html_svg() {

    file_export( HTML_TEX_SVG );

  }

  public void file_export_html_tex() {

    file_export( HTML_TEX_DELIMITED );

  }

  public void file_export_xhtml_tex() {

    file_export( XHTML_TEX );

  public void file_export_markdown() {

    file_export( MARKDOWN_PLAIN );

  }

*/

  private String read( final Path inputPath, final boolean concat )

/* Copyright 2020-2021 White Magic Software, Ltd. -- All rights reserved. */

package com.keenwrite;

import com.keenwrite.util.GenericBuilder;

import javafx.beans.value.ObservableValue;

import org.fxmisc.richtext.StyleClassedTextArea;

import org.fxmisc.richtext.model.Paragraph;

import org.reactfx.collection.LiveList;

import java.util.Collection;

import static com.keenwrite.Messages.get;

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

/**

 * Represents the absolute, relative, and maximum position of the caret. The

 * caret position is a character offset into the text.

 */

public class Caret {

  private final Mutator mMutator;

  public static GenericBuilder<Caret.Mutator, Caret> builder() {

    return GenericBuilder.of( Caret.Mutator::new, Caret::new );

  }

  /**

   * Used for building a new {@link Caret} instance.

   */

  public static class Mutator {

    /**

     * Caret's current paragraph index (i.e., current caret line number).

     */

    private ObservableValue<Integer> mParagraph;

    /**

     * Used to count the number of lines in the text editor document.

     */

    private LiveList<Paragraph<Collection<String>, String,

      Collection<String>>> mParagraphs;

    /**

     * Caret offset into the full text, represented as a string index.

     */

    private ObservableValue<Integer> mTextOffset;

    /**

     * Caret offset into the current paragraph, represented as a string index.

     */

    private ObservableValue<Integer> mParaOffset;

    /**

     * Total number of characters in the document.

     */

    private ObservableValue<Integer> mTextLength;

    /**

     * Configures this caret position using properties from the given editor.

     *

     * @param editor The text editor that has a caret with position properties.

     */

    public void setEditor( final StyleClassedTextArea editor ) {

      mParagraph = editor.currentParagraphProperty();

      mParagraphs = editor.getParagraphs();

      mParaOffset = editor.caretColumnProperty();

      mTextOffset = editor.caretPositionProperty();

      mTextLength = editor.lengthProperty();

    }

  }

  /**

   * Force using the builder pattern.

   */

  private Caret( final Mutator mutator ) {

    assert mutator != null;

    mMutator = mutator;

  }

  /**

   * Allows observers to be notified when the value of the caret changes.

   *

   * @return An observer for the caret's document offset.

   */

  public ObservableValue<Integer> textOffsetProperty() {

    return mMutator.mTextOffset;

  }

  /**

   * Answers whether the caret's offset into the text is between the given

   * offsets.

   *

   * @param began Starting value compared against the caret's text offset.

   * @param ended Ending value compared against the caret's text offset.

   * @return {@code true} when the caret's text offset is between the given

   * values, inclusively (for either value).

   */

  public boolean isBetweenText( final int began, final int ended ) {

    final var offset = getTextOffset();

    return began <= offset && offset <= ended;

  }

  /**

   * Answers whether the caret's offset into the paragraph is before the given

   * offset.

   *

   * @param offset Compared against the caret's paragraph offset.

   * @return {@code true} the caret's offset is before the given offset.

   */

  public boolean isBeforeColumn( final int offset ) {

    return getParaOffset() < offset;

  }

  /**

   * Answers whether the caret's offset into the text is before the given

   * text offset.

   *

   * @param offset Compared against the caret's text offset.

   * @return {@code true} the caret's offset is after the given offset.

   */

  public boolean isAfterColumn( final int offset ) {

    return getParaOffset() > offset;

  }

  /**

   * Answers whether the caret's offset into the text exceeds the length of

   * the text.

   *

   * @return {@code true} when the caret is at the end of the text boundary.

   */

  public boolean isAfterText() {

    return getTextOffset() >= getTextLength();

  }

  public boolean isAfter( final int offset ) {

    return offset >= getTextOffset();

  }

  private int getParagraph() {

    return mMutator.mParagraph.getValue();

  }

  /**

   * Returns the number of lines in the text editor.

   *

   * @return The size of the text editor's paragraph list plus one.

   */

  private int getParagraphCount() {

    return mMutator.mParagraphs.size() + 1;

  }

  /**

   * Returns the absolute position of the caret within the entire document.

   *

   * @return A zero-based index of the caret position.

   */

  private int getTextOffset() {

    return mMutator.mTextOffset.getValue();

  }

  /**

   * Returns the position of the caret within the current paragraph being

   * edited.

   *

   * @return A zero-based index of the caret position relative to the

   * current paragraph.

   */

  private int getParaOffset() {

    return mMutator.mParaOffset.getValue();

  }

  /**

   * Returns the total number of characters in the document being edited.

   *

   * @return A zero-based count of the total characters in the document.

   */

  private int getTextLength() {

    return mMutator.mTextLength.getValue();

  }

  /**

   * Returns a human-readable string that shows the current caret position

   * within the text. Typically this will include the current line number,

   * the number of lines, and the character offset into the text.

   * <p>

   * If the {@link Caret} has not been properly built, this will return a

   * string for the status bar having all values set to zero. This can happen

   * during unit testing, but should not happen any other time.

   * </p>

   *

   * @return A string to present to an end user.

   */

  @Override

  public String toString() {

    try {

      return get( STATUS_BAR_LINE,

                  getParagraph() + 1,

                  getParagraphCount(),

                  getTextOffset() + 1 );

    } catch( final Exception ex ) {

      return get( STATUS_BAR_LINE, 0, 0, 0 );

    }

  }

}

import static com.keenwrite.PermissiveCertificate.installTrustManager;

  private static void parse( final String[] args ) {

    assert args != null;

    final var arguments = new Arguments( new Launcher( args ) );

    final var parser = new CommandLine( arguments );

    parser.setColorScheme( ColourScheme.create() );

    final var exitCode = parser.execute( args );

    final var parseResult = parser.getParseResult();

    if( parseResult.isUsageHelpRequested() ) {

      System.exit( exitCode );

    }

  }

  /**

   * Suppress writing to standard error, suppresses writing log messages.

   */

  private static void disableLogging() {

    LogManager.getLogManager().reset();

    System.err.close();

  }

  private static void showAppInfo() {

    out( "%n%s version %s", APP_TITLE, APP_VERSION );

    out( "Copyright 2016-%s White Magic Software, Ltd.", APP_YEAR );

    out( "Portions copyright 2015-2020 Karl Tauber.%n" );

  }

import com.keenwrite.editors.definition.DefinitionEditor;

import com.keenwrite.editors.definition.TreeTransformer;

import com.keenwrite.editors.definition.yaml.YamlTreeTransformer;

import com.keenwrite.editors.markdown.MarkdownEditor;

import com.keenwrite.events.*;

import com.keenwrite.io.MediaType;

import com.keenwrite.preferences.Key;

import com.keenwrite.preferences.Workspace;

import com.keenwrite.preview.HtmlPreview;

import com.keenwrite.processors.HtmlPreviewProcessor;

import com.keenwrite.processors.Processor;

import com.keenwrite.processors.ProcessorContext;

import com.keenwrite.processors.ProcessorFactory;

import com.keenwrite.processors.r.InlineRProcessor;

import com.keenwrite.service.events.Notifier;

import com.keenwrite.sigils.PropertyKeyOperator;

import com.keenwrite.sigils.RKeyOperator;

import com.keenwrite.ui.explorer.FilePickerFactory;

import com.keenwrite.ui.heuristics.DocumentStatistics;

import com.keenwrite.ui.outline.DocumentOutline;

import com.keenwrite.util.GenericBuilder;

import com.panemu.tiwulfx.control.dock.DetachableTab;

import com.panemu.tiwulfx.control.dock.DetachableTabPane;

import javafx.application.Platform;

import javafx.beans.property.*;

import javafx.collections.ListChangeListener;

import javafx.concurrent.Task;

import javafx.event.ActionEvent;

import javafx.event.Event;

import javafx.event.EventHandler;

import javafx.scene.Node;

import javafx.scene.Scene;

import javafx.scene.control.*;

import javafx.scene.control.TreeItem.TreeModificationEvent;

import javafx.scene.input.KeyEvent;

import javafx.scene.layout.FlowPane;

import javafx.stage.Stage;

import javafx.stage.Window;

import org.greenrobot.eventbus.Subscribe;

import java.io.File;

import java.io.FileNotFoundException;

import java.nio.file.Path;

import java.util.*;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.ScheduledExecutorService;

import java.util.concurrent.ScheduledFuture;

import java.util.concurrent.atomic.AtomicBoolean;

import java.util.concurrent.atomic.AtomicReference;

import java.util.function.Function;

import java.util.function.UnaryOperator;

import java.util.stream.Collectors;

import static com.keenwrite.ExportFormat.NONE;

import static com.keenwrite.Messages.get;

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

import static com.keenwrite.constants.GraphicsConstants.ICON_DIALOG_NODE;

import static com.keenwrite.events.Bus.register;

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

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

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

import static com.keenwrite.processors.IdentityProcessor.IDENTITY;

import static com.keenwrite.processors.ProcessorContext.Mutator;

import static com.keenwrite.processors.ProcessorContext.builder;

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

import static java.lang.String.format;

import static java.lang.System.getProperty;

import static java.util.concurrent.Executors.newFixedThreadPool;

import static java.util.concurrent.Executors.newScheduledThreadPool;

import static java.util.concurrent.TimeUnit.SECONDS;

import static java.util.stream.Collectors.groupingBy;

import static javafx.application.Platform.runLater;

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

import static javafx.scene.control.ButtonType.*;

import static javafx.scene.control.TabPane.TabClosingPolicy.ALL_TABS;

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

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

import static javafx.util.Duration.millis;

import static javax.swing.SwingUtilities.invokeLater;

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

/**

 * Responsible for wiring together the main application components for a

 * particular {@link Workspace} (project). These include the definition views,

 * text editors, and preview pane along with any corresponding controllers.

 */

public final class MainPane extends SplitPane {

  private static final ExecutorService sExecutor = newFixedThreadPool( 1 );

  private static final Notifier sNotifier = Services.load( Notifier.class );

  /**

   * Used when opening files to determine how each file should be binned and

   * therefore what tab pane to be opened within.

   */

  private static final Set<MediaType> PLAIN_TEXT_FORMAT = Set.of(

    TEXT_MARKDOWN, TEXT_R_MARKDOWN, UNDEFINED

  );

  private final ScheduledExecutorService mSaver = newScheduledThreadPool( 1 );

  private final AtomicReference<ScheduledFuture<?>> mSaveTask =

    new AtomicReference<>();

  /**

   * Prevents re-instantiation of processing classes.

   */

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

    new HashMap<>();

  private final Workspace mWorkspace;

  /**

   * Groups similar file type tabs together.

   */

  private final List<TabPane> mTabPanes = new ArrayList<>();

  /**

   * Renders the actively selected plain text editor tab.

   */

  private final HtmlPreview mPreview;

  /**

   * Provides an interactive document outline.

   */

  private final DocumentOutline mOutline = new DocumentOutline();

  /**

   * Changing the active editor fires the value changed event. This allows

   * refreshes to happen when external definitions are modified and need to

   * trigger the processing chain.

   */

  private final ObjectProperty<TextEditor> mTextEditor =

    createActiveTextEditor();

  /**

   * Changing the active definition editor fires the value changed event. This

   * allows refreshes to happen when external definitions are modified and need

   * to trigger the processing chain.

   */

  private final ObjectProperty<TextDefinition> mDefinitionEditor;

  /**

   * Called when the definition data is changed.

   */

  private final EventHandler<TreeModificationEvent<Event>> mTreeHandler =

    event -> {

      process( getTextEditor() );

      save( getTextDefinition() );

    };

  /**

   * Tracks the number of detached tab panels opened into their own windows,

   * which allows unique identification of subordinate windows by their title.

   * It is doubtful more than 128 windows, much less 256, will be created.

   */

  private byte mWindowCount;

  private final DocumentStatistics mStatistics;

  /**

   * Adds all content panels to the main user interface. This will load the

   * configuration settings from the workspace to reproduce the settings from

   * a previous session.

   */

  public MainPane( final Workspace workspace ) {

    mWorkspace = workspace;

    mPreview = new HtmlPreview( workspace );

    mStatistics = new DocumentStatistics( workspace );

    mTextEditor.set( new MarkdownEditor( workspace ) );

    mDefinitionEditor = createActiveDefinitionEditor( mTextEditor );

    open( collect( getRecentFiles() ) );

    viewPreview();

    setDividerPositions( calculateDividerPositions() );

    // Once the main scene's window regains focus, update the active definition

    // editor to the currently selected tab.

    runLater( () -> getWindow().setOnCloseRequest( event -> {

      // Order matters: Open file names must be persisted before closing all.

      mWorkspace.save();

      if( closeAll() ) {

        Platform.exit();

        System.exit( 0 );

      }

      event.consume();

    } ) );

    register( this );

    initAutosave( workspace );

  }

  @Subscribe

  public void handle( final TextEditorFocusEvent event ) {

    mTextEditor.set( event.get() );

  }

  @Subscribe

  public void handle( final TextDefinitionFocusEvent event ) {

    mDefinitionEditor.set( event.get() );

  }

  /**

   * Typically called when a file name is clicked in the preview panel.

   *

   * @param event The event to process, must contain a valid file reference.

   */

  @Subscribe

  public void handle( final FileOpenEvent event ) {

    final File eventFile;

    final var eventUri = event.getUri();

    if( eventUri.isAbsolute() ) {

      eventFile = new File( eventUri.getPath() );

    }

    else {

      final var activeFile = getTextEditor().getFile();

      final var parent = activeFile.getParentFile();

      if( parent == null ) {

        clue( new FileNotFoundException( eventUri.getPath() ) );

        return;

      }

      else {

        final var parentPath = parent.getAbsolutePath();

        eventFile = Path.of( parentPath, eventUri.getPath() ).toFile();

      }

    }

    runLater( () -> open( eventFile ) );

  }

  @Subscribe

  public void handle( final CaretNavigationEvent event ) {

    runLater( () -> {

      final var textArea = getTextEditor().getTextArea();

      textArea.moveTo( event.getOffset() );

      textArea.requestFollowCaret();

      textArea.requestFocus();

    } );

  }

  @Subscribe

  @SuppressWarnings( "unused" )

  public void handle( final ExportFailedEvent event ) {

    final var os = getProperty( "os.name" );

    final var arch = getProperty( "os.arch" ).toLowerCase();

    final var bits = getProperty( "sun.arch.data.model" );

    final var title = Messages.get( "Alert.typesetter.missing.title" );

    final var header = Messages.get( "Alert.typesetter.missing.header" );

    final var version = Messages.get(

      "Alert.typesetter.missing.version",

      os,

      arch

        .replaceAll( "amd.*|i.*|x86.*", "X86" )

        .replaceAll( "mips.*", "MIPS" )

        .replaceAll( "armv.*", "ARM" ),

      bits );

    final var text = Messages.get( "Alert.typesetter.missing.installer.text" );

    // Download and install ConTeXt for {0} {1} {2}-bit

    final var content = format( "%s %s", text, version );

    final var flowPane = new FlowPane();

    final var link = new Hyperlink( text );

    final var label = new Label( version );

    flowPane.getChildren().addAll( link, label );

    final var alert = new Alert( ERROR, content, OK );

    alert.setTitle( title );

    alert.setHeaderText( header );

    alert.getDialogPane().contentProperty().set( flowPane );

    alert.setGraphic( ICON_DIALOG_NODE );

    link.setOnAction( ( e ) -> {

      alert.close();

      final var url = Messages.get( "Alert.typesetter.missing.installer.url" );

      runLater( () -> HyperlinkOpenEvent.fire( url ) );

    } );

    alert.showAndWait();

  }

  private void initAutosave( final Workspace workspace ) {

    final var rate = workspace.integerProperty( KEY_EDITOR_AUTOSAVE );

    rate.addListener(

      ( c, o, n ) -> {

        final var taskRef = mSaveTask.get();

        // Prevent multiple autosaves from running.

        if( taskRef != null ) {

          taskRef.cancel( false );

        }

        initAutosave( rate );

      }

    );

    // Start the save listener (avoids duplicating some code).

    initAutosave( rate );

  }

  private void initAutosave( final IntegerProperty rate ) {

    mSaveTask.set(

      mSaver.scheduleAtFixedRate(

        () -> {

          if( getTextEditor().isModified() ) {

            // Ensure the modified indicator is cleared by running on EDT.

            runLater( this::save );

          }

        }, 0, rate.intValue(), SECONDS

      )

    );

  }

  /**

   * TODO: Load divider positions from exported settings, see

   *   {@link #collect(SetProperty)} comment.

   */

  private double[] calculateDividerPositions() {

    final var ratio = 100f / getItems().size() / 100;

    final var positions = getDividerPositions();

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

      positions[ i ] = ratio * i;

    }

    return positions;

  }

  /**

   * Opens all the files into the application, provided the paths are unique.

   * This may only be called for any type of files that a user can edit

   * (i.e., update and persist), such as definitions and text files.

   *

   * @param files The list of files to open.

   */

  public void open( final List<File> files ) {

    files.forEach( this::open );

  }

  /**

   * This opens the given file. Since the preview pane is not a file that

   * can be opened, it is safe to add a listener to the detachable pane.

   * This will exit early if the given file is not a regular file (i.e., a

   * directory).

   *

   * @param inputFile The file to open.

   */

  private void open( final File inputFile ) {

    // Prevent opening directories (a non-existent "untitled.md" is fine).

    if( !inputFile.isFile() && inputFile.exists() ) {

      return;

    }

    final var tab = createTab( inputFile );

    final var node = tab.getContent();

    final var mediaType = MediaType.valueFrom( inputFile );

    final var tabPane = obtainTabPane( mediaType );

    tab.setTooltip( createTooltip( inputFile ) );

    tabPane.setFocusTraversable( false );

    tabPane.setTabClosingPolicy( ALL_TABS );

    tabPane.getTabs().add( tab );

    // Attach the tab scene factory for new tab panes.

    if( !getItems().contains( tabPane ) ) {

      addTabPane(

        node instanceof TextDefinition ? 0 : getItems().size(), tabPane

      );

    }

    if( inputFile.isFile() ) {

      getRecentFiles().add( inputFile.getAbsolutePath() );

    }

  }

  /**

   * Opens a new text editor document using the default document file name.

   */

  public void newTextEditor() {

    open( DOCUMENT_DEFAULT );

  }

  /**

   * Opens a new definition editor document using the default definition

   * file name.

   */

  public void newDefinitionEditor() {

    open( DEFINITION_DEFAULT );

  }

  /**

   * Iterates over all tab panes to find all {@link TextEditor}s and request

   * that they save themselves.

   */

  public void saveAll() {

    mTabPanes.forEach(

      tp -> tp.getTabs().forEach( tab -> {

        final var node = tab.getContent();

        if( node instanceof final TextEditor editor ) {

          save( editor );

        }

      } )

    );

  }

  /**

   * Requests that the active {@link TextEditor} saves itself. Don't bother

   * checking if modified first because if the user swaps external media from

   * an external source (e.g., USB thumb drive), save should not second-guess

   * the user: save always re-saves. Also, it's less code.

   */

  public void save() {

    save( getTextEditor() );

  }

  /**

   * Saves the active {@link TextEditor} under a new name.

   *

   * @param files The new active editor {@link File} reference, must contain

   *              at least one element.

   */

  public void saveAs( final List<File> files ) {

    assert files != null;

    assert !files.isEmpty();

    final var editor = getTextEditor();

    final var tab = getTab( editor );

    final var file = files.get( 0 );

    editor.rename( file );

    tab.ifPresent( t -> {

      t.setText( editor.getFilename() );

      t.setTooltip( createTooltip( file ) );

    } );

    save();

  }

  /**

   * Saves the given {@link TextResource} to a file. This is typically used

   * to save either an instance of {@link TextEditor} or {@link TextDefinition}.

   *

   * @param resource The resource to export.

   */

  private void save( final TextResource resource ) {

    try {

      resource.save();

    } catch( final Exception ex ) {

      clue( ex );

      sNotifier.alert(

        getWindow(), resource.getPath(), "TextResource.saveFailed", ex

      );

    }

  }

  /**

   * Closes all open {@link TextEditor}s; all {@link TextDefinition}s stay open.

   *

   * @return {@code true} when all editors, modified or otherwise, were

   * permitted to close; {@code false} when one or more editors were modified

   * and the user requested no closing.

   */

  public boolean closeAll() {

    var closable = true;

    for( final var tabPane : mTabPanes ) {

      final var tabIterator = tabPane.getTabs().iterator();

      while( tabIterator.hasNext() ) {

        final var tab = tabIterator.next();

        final var resource = tab.getContent();

        // The definition panes auto-save, so being specific here prevents

        // closing the definitions in the situation where the user wants to

        // continue editing (i.e., possibly save unsaved work).

        if( !(resource instanceof TextEditor) ) {

          continue;

        }

        if( canClose( (TextEditor) resource ) ) {

          tabIterator.remove();

          close( tab );

        }

        else {

          closable = false;

        }

      }

    }

    return closable;

  }

  /**

   * Calls the tab's {@link Tab#getOnClosed()} handler to carry out a close

   * event.

   *

   * @param tab The {@link Tab} that was closed.

   */

  private void close( final Tab tab ) {

    assert tab != null;

    final var handler = tab.getOnClosed();

    if( handler != null ) {

      handler.handle( new ActionEvent() );

    }

  }

  /**

   * Closes the active tab; delegates to {@link #canClose(TextResource)}.

   */

  public void close() {

    final var editor = getTextEditor();

    if( canClose( editor ) ) {

      close( editor );

    }

  }

  /**

   * Closes the given {@link TextResource}. This must not be called from within

   * a loop that iterates over the tab panes using {@code forEach}, lest a

   * concurrent modification exception be thrown.

   *

   * @param resource The {@link TextResource} to close, without confirming with

   *                 the user.

   */

  private void close( final TextResource resource ) {

    getTab( resource ).ifPresent(

      ( tab ) -> {

        close( tab );

        tab.getTabPane().getTabs().remove( tab );

      }

    );

  }

  /**

   * Answers whether the given {@link TextResource} may be closed.

   *

   * @param editor The {@link TextResource} to try closing.

   * @return {@code true} when the editor may be closed; {@code false} when

   * the user has requested to keep the editor open.

   */

  private boolean canClose( final TextResource editor ) {

    final var editorTab = getTab( editor );

    final var canClose = new AtomicBoolean( true );

    if( editor.isModified() ) {

      final var filename = new StringBuilder();

      editorTab.ifPresent( ( tab ) -> filename.append( tab.getText() ) );

      final var message = sNotifier.createNotification(

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

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

        filename.toString()

      );

      final var dialog = sNotifier.createConfirmation( getWindow(), message );

      dialog.showAndWait().ifPresent(

        save -> canClose.set( save == YES ? editor.save() : save == NO )

      );

    }

    return canClose.get();

  }

  private ObjectProperty<TextEditor> createActiveTextEditor() {

    final var editor = new SimpleObjectProperty<TextEditor>();

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

      if( n != null ) {

        mPreview.setBaseUri( n.getPath() );

        process( n );

      }

    } );

    return editor;

  }

  /**

   * Adds the HTML preview tab to its own, singular tab pane.

   */

  public void viewPreview() {

    viewTab( mPreview, TEXT_HTML, "Pane.preview.title" );

  }

  /**

   * Adds the document outline tab to its own, singular tab pane.

   */

  public void viewOutline() {

    viewTab( mOutline, APP_DOCUMENT_OUTLINE, "Pane.outline.title" );

  }

  public void viewStatistics() {

    viewTab( mStatistics, APP_DOCUMENT_STATISTICS, "Pane.statistics.title" );

  }

  public void viewFiles() {

    try {

      final var factory = new FilePickerFactory( getWorkspace() );

      final var fileManager = factory.createModeless();

      viewTab( fileManager, APP_FILE_MANAGER, "Pane.files.title" );

    } catch( final Exception ex ) {

      clue( ex );

    }

  }

  private void viewTab(

    final Node node, final MediaType mediaType, final String key ) {

    final var tabPane = obtainTabPane( mediaType );

    for( final var tab : tabPane.getTabs() ) {

      if( tab.getContent() == node ) {

        return;

      }

    }

    tabPane.getTabs().add( createTab( get( key ), node ) );

    addTabPane( tabPane );

  }

  public void viewRefresh() {

    mPreview.refresh();

  }

  /**

   * Returns the tab that contains the given {@link TextEditor}.

   *

   * @param editor The {@link TextEditor} instance to find amongst the tabs.

   * @return The first tab having content that matches the given tab.

   */

  private Optional<Tab> getTab( final TextResource editor ) {

    return mTabPanes.stream()

                    .flatMap( pane -> pane.getTabs().stream() )

                    .filter( tab -> editor.equals( tab.getContent() ) )

                    .findFirst();

  }

  /**

   * Creates a new {@link DefinitionEditor} wrapped in a listener that

   * is used to detect when the active {@link DefinitionEditor} has changed.

   * Upon changing, the variables are interpolated and the active text editor

   * is refreshed.

   *

   * @param textEditor Text editor to update with the revised resolved map.

   * @return A newly configured property that represents the active

   * {@link DefinitionEditor}, never null.

   */

  private ObjectProperty<TextDefinition> createActiveDefinitionEditor(

    final ObjectProperty<TextEditor> textEditor ) {

    final var defEditor = new SimpleObjectProperty<>(

      createDefinitionEditor()

    );

    defEditor.addListener( ( c, o, n ) -> process( textEditor.get() ) );

    return defEditor;

  }

  private Tab createTab( final String filename, final Node node ) {

    return new DetachableTab( filename, node );

  }

  private Tab createTab( final File file ) {

    final var r = createTextResource( file );

    final var tab = createTab( r.getFilename(), r.getNode() );

    r.modifiedProperty().addListener(

      ( c, o, n ) -> tab.setText( r.getFilename() + (n ? "*" : "") )

    );

    // This is called when either the tab is closed by the user clicking on

    // the tab's close icon or when closing (all) from the file menu.

    tab.setOnClosed(

      ( __ ) -> getRecentFiles().remove( file.getAbsolutePath() )

    );

    // When closing a tab, give focus to the newly revealed tab.

    tab.selectedProperty().addListener( ( c, o, n ) -> {

      if( n != null && n ) {

        final var pane = tab.getTabPane();

        if( pane != null ) {

          pane.requestFocus();

        }

      }

    } );

    tab.tabPaneProperty().addListener( ( cPane, oPane, nPane ) -> {

      if( nPane != null ) {

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

          if( n != null && n ) {

            final var selected = nPane.getSelectionModel().getSelectedItem();

            final var node = selected.getContent();

            node.requestFocus();

          }

        } );

      }

    } );

    return tab;

  }

  /**

   * Creates bins for the different {@link MediaType}s, which eventually are

   * added to the UI as separate tab panes. If ever a general-purpose scene

   * exporter is developed to serialize a scene to an FXML file, this could

   * be replaced by such a class.

   * <p>

   * When binning the files, this makes sure that at least one file exists

   * for every type. If the user has opted to close a particular type (such

   * as the definition pane), the view will suppressed elsewhere.

   * </p>

   * <p>

   * The order that the binned files are returned will be reflected in the

   * order that the corresponding panes are rendered in the UI.

   * </p>

   *

   * @param paths The file paths to bin according to their type.

   * @return An in-order list of files, first by structured definition files,

   * then by plain text documents.

   */

  private List<File> collect( final SetProperty<String> paths ) {

    // Treat all files destined for the text editor as plain text documents

    // so that they are added to the same pane. Grouping by TEXT_PLAIN is a

    // bit arbitrary, but means explicitly capturing TEXT_PLAIN isn't needed.

    final Function<MediaType, MediaType> bin =

      m -> PLAIN_TEXT_FORMAT.contains( m ) ? TEXT_PLAIN : m;

    // Create two groups: YAML files and plain text files. The order that

    // the elements are listed in the enumeration for media types determines

    // what files are loaded first. Variable definitions come before all other

    // plain text documents.

    final var bins = paths

      .stream()

      .collect(

        groupingBy(

          path -> bin.apply( MediaType.fromFilename( path ) ),

          () -> new TreeMap<>( Enum::compareTo ),

          Collectors.toList()

        )

      );

    bins.putIfAbsent( TEXT_YAML, List.of( DEFINITION_DEFAULT.toString() ) );

    bins.putIfAbsent( TEXT_PLAIN, List.of( DOCUMENT_DEFAULT.toString() ) );

    final var result = new LinkedList<File>();

    // Ensure that the same types are listed together (keep insertion order).

    bins.forEach( ( mediaType, files ) -> result.addAll(

      files.stream().map( File::new ).toList() )

    );

    return result;

  }

  /**

   * Force the active editor to update, which will cause the processor

   * to re-evaluate the interpolated definition map thereby updating the

   * preview pane.

   *

   * @param editor Contains the source document to update in the preview pane.

   */

  private void process( final TextEditor editor ) {

    // Ensure processing does not run on the JavaFX thread, which frees the

    // text editor immediately for caret movement. The preview will have a

    // slight delay when catching up to the caret position.

    final var task = new Task<Void>() {

      @Override

      public Void call() {

        try {

          final var p = mProcessors.getOrDefault( editor, IDENTITY );

          p.apply( editor == null ? "" : editor.getText() );

        } catch( final Exception ex ) {

          clue( ex );

        }

        return null;

      }

    };

    // TODO: Each time the editor successfully runs the processor the task is

    //   considered successful. Due to the rapid-fire nature of processing

    //   (e.g., keyboard navigation, fast typing), it isn't necessary to

    //   scroll each time.

    //   The algorithm:

    //   1. Peek at the oldest time.

    //   2. If the difference between the oldest time and current time exceeds

    //      250 milliseconds, then invoke the scrolling.

    //   3. Insert the current time into the circular queue.

    task.setOnSucceeded(

      e -> invokeLater( () -> mPreview.scrollTo( CARET_ID ) )

    );

    // Prevents multiple process requests from executing simultaneously (due

    // to having a restricted queue size).

    sExecutor.execute( task );

  }

  /**

   * Lazily creates a {@link TabPane} configured to listen for tab select

   * events. The tab pane is associated with a given media type so that

   * similar files can be grouped together.

   *

   * @param mediaType The media type to associate with the tab pane.

   * @return An instance of {@link TabPane} that will handle tab docking.

   */

  private TabPane obtainTabPane( final MediaType mediaType ) {

    for( final var pane : mTabPanes ) {

      for( final var tab : pane.getTabs() ) {

        final var node = tab.getContent();

        if( node instanceof TextResource r && r.supports( mediaType ) ) {

          return pane;

        }

      }

    }

    final var pane = createTabPane();

    mTabPanes.add( pane );

    return pane;

  }

  /**

   * Creates an initialized {@link TabPane} instance.

   *

   * @return A new {@link TabPane} with all listeners configured.

   */

  private TabPane createTabPane() {

    final var tabPane = new DetachableTabPane();

    initStageOwnerFactory( tabPane );

    initTabListener( tabPane );

    return tabPane;

  }

  /**

   * When any {@link DetachableTabPane} is detached from the main window,

   * the stage owner factory must be given its parent window, which will

   * own the child window. The parent window is the {@link MainPane}'s

   * {@link Scene}'s {@link Window} instance.

   *

   * <p>

   * This will derives the new title from the main window title, incrementing

   * the window count to help uniquely identify the child windows.

   * </p>

   *

   * @param tabPane A new {@link DetachableTabPane} to configure.

   */

  private void initStageOwnerFactory( final DetachableTabPane tabPane ) {

    tabPane.setStageOwnerFactory( ( stage ) -> {

      final var title = get(

        "Detach.tab.title",

        ((Stage) getWindow()).getTitle(), ++mWindowCount

      );

      stage.setTitle( title );

      return getScene().getWindow();

    } );

  }

  /**

   * Responsible for configuring the content of each {@link DetachableTab} when

   * it is added to the given {@link DetachableTabPane} instance.

   * <p>

   * For {@link TextEditor} contents, an instance of {@link ScrollEventHandler}

   * is initialized to perform synchronized scrolling between the editor and

   * its preview window. Additionally, the last tab in the tab pane's list of

   * tabs is given focus.

   * </p>

   * <p>

   * Note that multiple tabs can be added simultaneously.

   * </p>

   *

   * @param tabPane A new {@link TabPane} to configure.

   */

  private void initTabListener( final TabPane tabPane ) {

    tabPane.getTabs().addListener(

      ( final ListChangeListener.Change<? extends Tab> listener ) -> {

        while( listener.next() ) {

          if( listener.wasAdded() ) {

            final var tabs = listener.getAddedSubList();

            tabs.forEach( tab -> {

              final var node = tab.getContent();

              if( node instanceof TextEditor ) {

                initScrollEventListener( tab );

              }

            } );

            // Select and give focus to the last tab opened.

            final var index = tabs.size() - 1;

            if( index >= 0 ) {

              final var tab = tabs.get( index );

              tabPane.getSelectionModel().select( tab );

              tab.getContent().requestFocus();

            }

          }

        }

      }

    );

  }

  /**

   * Synchronizes scrollbar positions between the given {@link Tab} that

   * contains an instance of {@link TextEditor} and {@link HtmlPreview} pane.

   *

   * @param tab The container for an instance of {@link TextEditor}.

   */

  private void initScrollEventListener( final Tab tab ) {

    final var editor = (TextEditor) tab.getContent();

    final var scrollPane = editor.getScrollPane();

    final var scrollBar = mPreview.getVerticalScrollBar();

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

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

  }

  private void addTabPane( final int index, final TabPane tabPane ) {

    final var items = getItems();

    if( !items.contains( tabPane ) ) {

      items.add( index, tabPane );

    }

  }

  private void addTabPane( final TabPane tabPane ) {

    addTabPane( getItems().size(), tabPane );

  }

  private GenericBuilder<Mutator, ProcessorContext> createProcessorContextBuilder() {

    return builder()

      .with( Mutator::setDefinitions, this::getDefinitions )

      .with( Mutator::setWorkspace, mWorkspace )

      .with( Mutator::setCaret, () -> getTextEditor().getCaret() );

  }

  public ProcessorContext createProcessorContext() {

    return createProcessorContext( null, NONE );

  }

  /**

   * @param outputPath Used when exporting to a PDF file (binary).

   * @param format     Used when processors export to a new text format.

   * @return A new {@link ProcessorContext} to use when creating an instance of

   * {@link Processor}.

   */

  public ProcessorContext createProcessorContext(

    final Path outputPath, final ExportFormat format ) {

    final var textEditor = getTextEditor();

    final var inputPath = textEditor.getPath();

    return createProcessorContextBuilder()

      .with( Mutator::setInputPath, inputPath )

      .with( Mutator::setOutputPath, outputPath )

      .with( Mutator::setExportFormat, format )

      .build();

  }

  /**

   * @param inputPath Used by {@link ProcessorFactory} to determine

   *                  {@link Processor} type to create based on file type.

   * @return A new {@link ProcessorContext} to use when creating an instance of

   * {@link Processor}.

   */

  private ProcessorContext createProcessorContext( final Path inputPath ) {

    return createProcessorContextBuilder()

      .with( Mutator::setInputPath, inputPath )

      .with( Mutator::setExportFormat, NONE )

      .build();

  }

  private TextResource createTextResource( final File file ) {

    // TODO: Create PlainTextEditor that's returned by default.

    return MediaType.valueFrom( file ) == TEXT_YAML