Dave Jarvis' Repositories

# thousandth, millionth, billionth, etc. regardless of oridinal. If ordinal

# is TRUE, this will return the ordinal name. This will not produce ordinals

# for numbers greater than 100.

#

# If scaled is TRUE, this will write large numbers as comma-separated values.

# -----------------------------------------------------------------------------

cms <- function( n, ordinal = FALSE, scaled = TRUE ) {

  n <- x( n )

  if( n == 0 ) {

    if( ordinal ) {

      return( "zeroth" )

    }

    return( "zero" )

  }

  # Concatenate this a little later.

  if( n < 0 ) {

    result = "negative "

    n = abs( n )

  }

  if( n > 999 && scaled ) {

    scales <- c(

      "thousand", "million", "billion", "trillion", "quadrillion",

      "quintillion", "sextillion", "septillion", "octillion", "nonillion",

      "decillion", "undecillion", "duodecillion", "tredecillion",

      "quattuordecillion", "quindecillion", "sexdecillion", "septendecillion",

      "octodecillion", "novemdecillion", "vigintillion", "centillion",

      "quadrillion", "quitillion", "sextillion"

    );

    d <- round( n / (10 ^ (log10( n ) - log10( n ) %% 3)) );

    n <- floor( log10( n ) ) / 3;

    return( paste( cms( d ), scales[ n ] ) );

  }

  # Do not spell out numbers greater than one hundred.

  if( n > 100 ) {

    # Comma-separated numbers.

    return( commas( n ) )

  }

  # Don't go beyond 100.

  if( n == 100 ) {

    if( ordinal ) {

      return( "one hundredth" )

    }

    return( "one hundred" )

  }

  # Samuel Langhorne Clemens noted English has too many exceptions.

  small = c(

    "one", "two", "three", "four", "five", "six", "seven", "eight", "nine",

    "ten", "eleven", "twelve", "thirteen", "fourteen", "fifteen", "sixteen",

    "seventeen", "eighteen", "nineteen"

  )

  ord_small = c(

    "first", "second", "third", "fourth", "fifth", "sixth", "seventh",

    "eighth", "ninth", "tenth", "eleventh", "twelfth", "thirteenth",

    "fourteenth", "fifteenth", "sixteenth", "seventeenth", "eighteenth",

    "nineteenth", "twentieth"

  )

  # After this, the number (n) is between 20 and 99.

  if( n < 20 ) {

    if( ordinal ) {

      return( .subset( ord_small, n %% 100 ) )

    }

    return( .subset( small, n %% 100 ) )

  }

  tens = c( "",

    "twenty", "thirty", "forty", "fifty",

    "sixty", "seventy", "eighty", "ninety"

  )

  ord_tens = c( "",

    "twentieth", "thirtieth", "fortieth", "fiftieth",

    "sixtieth", "seventieth", "eightieth", "ninetieth"

  )

  ones_index = n %% 10

  n = n %/% 10

  # No number in the ones column, so the number must be a multiple of ten.

  if( ones_index == 0 ) {

    if( ordinal ) {

      return( .subset( ord_tens, n ) )

    }

    return( .subset( tens, n ) )

  }

  # Find the value from the ones column.

  if( ordinal ) {

    unit_1 = .subset( ord_small, ones_index )

  }

  else {

    unit_1 = .subset( small, ones_index )

  }

  # Find the tens column.

  unit_10 = .subset( tens, n )

  # Hyphenate the tens and the ones together.

  concat( unit_10, concat( "-", unit_1 ) )

}

# -----------------------------------------------------------------------------

# Returns a number as a comma-delimited string. This is a work-around

# until Renjin fixes https://github.com/bedatadriven/renjin/issues/338

# -----------------------------------------------------------------------------

commas <- function( n ) {

  n <- x( n )

  s <- sprintf( "%03.0f", n %% 1000 )

  n <- n %/% 1000

  while( n > 0 ) {

    s <- concat( sprintf( "%03.0f", n %% 1000 ), ',', s )

    n <- n %/% 1000

  }

  gsub( "^0*", '', s )

}

# -----------------------------------------------------------------------------

# Returns a human-readable string that provides the elapsed time between

# two numbers in terms of years, months, and days. If any unit value is zero,

# the unit is not included. The words (year, month, day) are pluralized

# according to English grammar. The numbers are written out according to

# Chicago Manual of Style. This applies the serial comma.

#

# Both numbers are offsets relative to the anchor date.

#

# If all unit values are zero, this returns s ("same day" by default).

#

# If the start date (began) is greater than end date (ended), the dates are

# swapped before calculations are performed. This allows any two dates

# to be compared and positive unit values are always returned.

# -----------------------------------------------------------------------------

elapsed <- function( began, ended, s = "same day" ) {

  began = when( anchor, began )

  ended = when( anchor, ended )

  # Swap the dates if the end date comes before the start date.

  if( as.integer( ended - began ) < 0 ) {

    tempd = began

    began = ended

    ended = tempd

  }

  # Calculate number of elapsed years.

  years = length( seq( from = began, to = ended, by = "year" ) ) - 1

  # Move the start date up by the number of elapsed years.

  if( years > 0 ) {

    began = seq( began, length = 2, by = concat( years, " years" ) )[2]

    years = pl.numeric( "year", years )

  }

  else {

    # Zero years.

    years = ""

  }

  # Calculate number of elapsed months, excluding years.

  months = length( seq( from = began, to = ended, by = "month" ) ) - 1

  # Move the start date up by the number of elapsed months

  if( months > 0 ) {

    began = seq( began, length = 2, by = concat( months, " months" ) )[2]

    months = pl.numeric( "month", months )

  }

  else {

    # Zero months

    months = ""

  }

  # Calculate number of elapsed days, excluding months and years.

  days = length( seq( from = began, to = ended, by = "day" ) ) - 1

  if( days > 0 ) {

    days = pl.numeric( "day", days )

  }

  else {

    # Zero days

    days = ""

  }

  if( years <= 0 && months <= 0 && days <= 0 ) {

    return( s )

  }

  # Put them all in a vector, then remove the empty values.

  s <- c( years, months, days )

  s <- s[ s != "" ]

  r <- paste( s, collapse = ", " )

  # If all three items are present, replace the last comma with ", and".

  if( length( s ) > 2 ) {

    return( gsub( "(.*),", "\\1, and", r ) )

  }

  # Does nothing if no commas are present.

  gsub( "(.*),", "\\1 and", r )

}

# -----------------------------------------------------------------------------

# Returns the number (n) in English followed by the plural or singular

# form of the given string (s; resumably a noun), if applicable, according

# to English grammar. That is, pl.numeric( "wolf", 5 ) will return

# "five wolves".

# -----------------------------------------------------------------------------

pl.numeric <- function( s, n ) {

  concat( cms( n ), concat( " ", pluralize( word=s, n=n ) ) )

}

# -----------------------------------------------------------------------------

# Pluralize s if n is not equal to 1.

# -----------------------------------------------------------------------------

pl <- function( s, count=2 ) {

  pluralize( word=s, n=count )

}

# -----------------------------------------------------------------------------

# Name of the season, starting with an capital letter.

# -----------------------------------------------------------------------------

season <- function( n, format = "%Y-%m-%d" ) {

  WS <- as.Date("2016-12-15", "%Y-%m-%d") # Winter Solstice

  SE <- as.Date("2016-03-15", "%Y-%m-%d") # Spring Equinox

  SS <- as.Date("2016-06-15", "%Y-%m-%d") # Summer Solstice

  AE <- as.Date("2016-09-15", "%Y-%m-%d") # Autumn Equinox

  d <- when( anchor, n )

  d <- as.Date( strftime( d, format="2016-%m-%d" ) )

  ifelse( d >= WS | d < SE, "Winter",

    ifelse( d >= SE & d < SS, "Spring",

      ifelse( d >= SS & d < AE, "Summer", "Autumn" )

    )

  )

}

# -----------------------------------------------------------------------------

# Converts the first letter in a string to lowercase

# -----------------------------------------------------------------------------

lc <- function( s ) {

  concat( tolower( substr( s, 1, 1 ) ), substr( s, 2, nchar( s ) ) )

}

# -----------------------------------------------------------------------------

# Converts the entire string to lowercase

# -----------------------------------------------------------------------------

lower <- tolower

# -----------------------------------------------------------------------------

# Converts the first letter in a string to uppercase

# -----------------------------------------------------------------------------

uc <- function( s ) {

  concat( toupper( substr( s, 1, 1 ) ), substr( s, 2, nchar( s ) ) )

}

# -----------------------------------------------------------------------------

# Returns the number of days between the given dates.

# -----------------------------------------------------------------------------

days <- function( d1, d2, format = "%Y-%m-%d" ) {

  dates = c( d1, d2 )

  dt = strptime( dates, format = format )

  as.integer( difftime( dates[2], dates[1], units = "days" ) )

}

weeks <- function( began, ended ) {

  began = when( anchor, began )

  ended = when( anchor, ended )

  if( as.integer( ended - began ) < 0 ) {

    tempd = began

    began = ended

    ended = tempd

  }

  # Calculate number of elapsed weeks.

  length( seq( from = began, to = ended, by = "weeks" ) ) - 1

}

# -----------------------------------------------------------------------------

# Returns the number of years elapsed.

# -----------------------------------------------------------------------------

years <- function( began, ended ) {

  began = when( anchor, began )

  ended = when( anchor, ended )

  # Swap the dates if the end date comes before the start date.

  if( as.integer( ended - began ) < 0 ) {

    tempd = began

    began = ended

    ended = tempd

  }

  # Calculate number of elapsed years.

  length( seq( from = began, to = ended, by = "year" ) ) - 1

}

# -----------------------------------------------------------------------------

# Full name of the month, starting with a capital letter.

# -----------------------------------------------------------------------------

month <- function( n ) {

  # Faster than month.name[ x( n ) ]

  .subset( month.name, x( n ) )

}

# -----------------------------------------------------------------------------

# -----------------------------------------------------------------------------

money <- function( n ) {

  commas( x( n ) )

}

# -----------------------------------------------------------------------------

# -----------------------------------------------------------------------------

timeline <- function( n ) {

  concat( weekday( n ), ", ", annal( n ), " (", season( n ), ")" )

}

# -----------------------------------------------------------------------------

# Rounds to the nearest base value (e.g., round to nearest 10).

#

# @param base The nearest value to round to.

# -----------------------------------------------------------------------------

round.up <- function( n, base = 5 ) {

  base * round( x( n ) / base )

}

# -----------------------------------------------------------------------------

# Removes common accents from letters.

#

# @param s The string to remove diacritics from.

    "millenium",

  def v_jackson = '2.15.1'

  def v_echosvg = '0.3'

  def v_picocli = '4.7.3'

  implementation 'org.codehaus.plexus:plexus-utils:3.5.1'

    warning "Missing ${CONTAINER_COMPRESSED_PATH}; use build follwed by save"

While CJK font familes for the preview have the following names:

  -jar keenwrite.jar $@

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

import javafx.scene.control.Tab;

import javafx.scene.control.TabPane;

import javafx.scene.control.Tooltip;

import javafx.scene.control.TreeItem.TreeModificationEvent;

import javafx.scene.input.KeyEvent;

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

import java.util.function.Function;

import java.util.stream.Collectors;

import static com.keenwrite.ExportFormat.NONE;

import static com.keenwrite.Launcher.terminate;

import static com.keenwrite.Messages.get;

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

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

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

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

import static com.keenwrite.io.MediaType.TypeName.TEXT;

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.awt.Desktop.getDesktop;

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.ButtonType.NO;

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

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

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

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

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

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;

  private final ObjectProperty<SpellChecker> mSpellChecker;

  private final TextEditorSpellChecker mEditorSpeller;

  /**

   * 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 VariableNameInjector mVariableNameInjector;

  private final RBootstrapController mRBootstrapController;

  private final DocumentStatistics mStatistics;

  @SuppressWarnings( {"FieldCanBeLocal", "unused"} )

  private final TypesetterInstaller mInstallWizard;

  /**

   * 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;

    mSpellChecker = createSpellChecker();

    mEditorSpeller = createTextEditorSpellChecker( mSpellChecker );

    mPreview = new HtmlPreview( workspace );

    mStatistics = new DocumentStatistics( workspace );

    mTextEditor.set( createMarkdownEditor( DOCUMENT_DEFAULT ) );

    mDefinitionEditor = createActiveDefinitionEditor( mTextEditor );

    mVariableNameInjector = new VariableNameInjector( mWorkspace );

    mRBootstrapController = new RBootstrapController(

      mWorkspace, this::getDefinitions );

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

        terminate( 0 );

      }

      event.consume();

    } ) );

    register( this );

    initAutosave( workspace );

    restoreSession();

    runLater( this::restoreFocus );

    mInstallWizard = new TypesetterInstaller( workspace );

  }

  /**

   * Called when spellchecking can be run. This will reload the dictionary

   * into memory once, and then re-use it for all the existing text editors.

   *

   * @param event The event to process, having a populated word-frequency map.

   */

  @Subscribe

  public void handle( final LexiconLoadedEvent event ) {

    final var lexicon = event.getLexicon();

    try {

      final var checker = SymSpellSpeller.forLexicon( lexicon );

      mSpellChecker.set( checker );

    } catch( final Exception ex ) {

      clue( ex );

    }

  }

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

      }

    }

    final var mediaType = MediaTypeExtension.fromFile( eventFile );

    runLater( () -> {

      // Open text files locally.

      if( mediaType.isType( TEXT ) ) {

        open( eventFile );

      }

      else {

        try {

          // Delegate opening all other file types to the operating system.

          getDesktop().open( eventFile );

        } catch( final Exception ex ) {

          clue( ex );

        }

      }

    } );

  }

  @Subscribe

  public void handle( final CaretNavigationEvent event ) {

    runLater( () -> {

      final var textArea = getTextEditor();

      textArea.moveTo( event.getOffset() );

      textArea.requestFocus();

    } );

  }

  @Subscribe

  public void handle( final InsertDefinitionEvent<String> event ) {

    final var leaf = event.getLeaf();

    final var editor = mTextEditor.get();

    mVariableNameInjector.insert( editor, leaf );

  }

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

    }

  }

  /**

   * Gives focus to the most recently edited document and attempts to move

   * the caret to the most recently known offset into said document.

   */

  private void restoreSession() {

    final var workspace = getWorkspace();

    final var file = workspace.fileProperty( KEY_UI_RECENT_DOCUMENT );

    final var offset = workspace.integerProperty( KEY_UI_RECENT_OFFSET );

    for( final var pane : mTabPanes ) {

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

        final var tooltip = tab.getTooltip();

        if( tooltip != null ) {

          final var tabName = tooltip.getText();

          final var fileName = file.getValue().toString();

          if( tabName.equalsIgnoreCase( fileName ) ) {

            final var node = tab.getContent();

            pane.getSelectionModel().select( tab );

            node.requestFocus();

            if( node instanceof TextEditor editor ) {

              editor.moveTo( offset.getValue() );

            }

            break;

          }

        }

      }

    }

  }

  /**

   * Sets the focus to the middle pane, which contains the text editor tabs.

   */

  private void restoreFocus() {

    // Work around a bug where focusing directly on the middle pane results

    // in the R engine not loading variables properly.

    mTabPanes.get( 0 ).requestFocus();

    // This is the only line that should be required.

    mTabPanes.get( 1 ).requestFocus();

  }

  /**

   * 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() {

    iterateEditors( this::save );

  }

  /**

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

    // If the file type has changed, refresh the processors.

    final var mediaType = MediaType.valueFrom( file );

    final var typeChanged = !editor.isMediaType( mediaType );

    if( typeChanged ) {

      removeProcessor( editor );

    }

    editor.rename( file );

    tab.ifPresent( t -> {

      t.setText( editor.getFilename() );

      t.setTooltip( createTooltip( file ) );

    } );

    if( typeChanged ) {

      updateProcessors( editor );

      process( editor );

    }

    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 void iterateEditors( final Consumer<TextEditor> consumer ) {

    mTabPanes.forEach(

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

        final var node = tab.getContent();

        if( node instanceof final TextEditor editor ) {

          consumer.accept( editor );

        }

      } )

    );

  }

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

    Engine.clear();

    mRBootstrapController.update();

  }

  /**

   * 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 ) -> {

      final var editor = textEditor.get();

      if( editor.isMediaType( TEXT_R_MARKDOWN ) ) {

        // Initialize R before the editor is added.

        mRBootstrapController.update();

      }

      process( editor );

    } );

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

    );