Dave Jarvis' Repositories

* [Theme Pack](https://github.com/DaveJarvis/keenwrite-themes/releases/latest/download/theme-pack.zip)

* [Theme Pack](https://github.com/DaveJarvis/keenwrite-themes/releases/latest/download/theme-pack.zip)

      file( "${projectDir}/bug-filter.xml" )

    '--add-opens=javafx.graphics/javafx.scene=ALL-UNNAMED',

    '--add-opens=javafx.controls/javafx.scene.control=ALL-UNNAMED',

    '--add-opens=javafx.controls/javafx.scene.control.skin=ALL-UNNAMED',

    '--add-opens=javafx.graphics/javafx.scene.text=ALL-UNNAMED',

    '--add-opens=javafx.graphics/com.sun.javafx.css=ALL-UNNAMED',

    '--add-opens=javafx.graphics/com.sun.javafx.text=ALL-UNNAMED',

    '--add-exports=javafx.base/com.sun.javafx.event=ALL-UNNAMED',

    '--add-exports=javafx.graphics/com.sun.javafx.application=ALL-UNNAMED',

    '--add-exports=javafx.graphics/com.sun.javafx.geom=ALL-UNNAMED',

    '--add-exports=javafx.graphics/com.sun.javafx.text=ALL-UNNAMED',

    '--add-exports=javafx.graphics/com.sun.javafx.scene=ALL-UNNAMED',

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

    '--add-exports=javafx.graphics/com.sun.javafx.scene.traversal=ALL-UNNAMED',

  def v_jackson = '2.15.3'

  implementation 'com.miglayout:miglayout-javafx:11.2'

      "-Xlint:unchecked",

      "-Xlint:deprecation",

      "-Aproject=${applicationPackage}/${applicationName}"

        .collect { it.isDirectory() ? it : zipTree( it ) }

# Carlito (Calibri replacement)

ADD "https://github.com/googlefonts/carlito/raw/main/fonts/ttf/Carlito-Regular.ttf" "Carlito-Regular.ttf"

ADD "https://github.com/googlefonts/carlito/raw/main/fonts/ttf/Carlito-Bold.ttf" "Carlito-Bold.ttf"

ADD "https://github.com/googlefonts/carlito/raw/main/fonts/ttf/Carlito-Italic.ttf" "Carlito-Italic.ttf"

ADD "https://github.com/googlefonts/carlito/raw/main/fonts/ttf/Carlito-BoldItalic.ttf" "Carlito-BoldItalic.ttf"

# Open Sans Emoji

ADD "https://github.com/MorbZ/OpenSansEmoji/raw/master/OpenSansEmoji.ttf" "OpenSansEmoji.ttf"

# Underwood Quiet Tab

ADD "https://site.xavier.edu/polt/typewriters/Underwood_Quiet_Tab.ttf" "Underwood_Quiet_Tab.ttf"

# Archives

ADD "https://www.omnibus-type.com/wp-content/uploads/Archivo-Narrow.zip" "archivo-narrow.zip"

ADD "https://fonts.google.com/download?family=Courier%20Prime" "courier-prime.zip"

ADD "https://fonts.google.com/download?family=Inconsolata" "inconsolata.zip"

ADD "https://fonts.google.com/download?family=Libre%20Baskerville" "libre-baskerville.zip"

ADD "https://fonts.google.com/download?family=Niconne" "niconne.zip"

ADD "https://fonts.google.com/download?family=Nunito" "nunito.zip"

ADD "https://fonts.google.com/download?family=Roboto" "roboto.zip"

ADD "https://fonts.google.com/download?family=Roboto%20Mono" "roboto-mono.zip"

ADD "https://github.com/adobe-fonts/source-serif/releases/download/4.004R/source-serif-4.004.zip" "source-serif.zip"

    "$FONTS_DIR" "$INSTALL_DIR" \

    "$TARGET_DIR" "$SOURCE_DIR" "$THEMES_DIR" "$IMAGES_DIR" "$CACHES_DIR" && \

  unzip -j -o -d $FONTS_DIR $DOWNLOAD_DIR/archivo-narrow.zip "Archivo-Narrow/otf/*.otf" && \

  unzip -j -o -d $FONTS_DIR $DOWNLOAD_DIR/inconsolata.zip "**/Inconsolata/*.ttf" && \

  unzip -j -o -d $FONTS_DIR $DOWNLOAD_DIR/nunito.zip "static/*.ttf" && \

  unzip -j -o -d $FONTS_DIR $DOWNLOAD_DIR/roboto-mono.zip "static/*.ttf" && \

  unzip -j -o -d $FONTS_DIR $DOWNLOAD_DIR/source-serif.zip "source-serif-4.004/OTF/SourceSerif4-*.otf" && \

  mv $DOWNLOAD_DIR/*tf $FONTS_DIR && \

  #rsync \

    #--recursive --links --times \

    #--info=progress2,remove,symsafe,flist,del \

    #--human-readable --del \

    #rsync://contextgarden.net/minimals/current/modules/ modules && \

  #rsync \

    #-rlt --exclude=/VERSION --del modules/*/ tex/texmf-modules && \

  rm -f $DOWNLOAD_DIR/*.zip && \

Broadly, the container is built locally then deployed to a web server capable

of serving static web pages.

Upgrade the containerization software as follows:

1. Set `Wizard.typesetter.container.image.version` to the latest image version.

The containerization software versions are changed.

./manage.sh --build

./manage.sh --export

./manage.sh --publish

  $log "Building"

The `type-name` can be any alphanumeric value, starting with a letter.

Type names are user-defined categories for the item type. Labels are

user-defined identifiers that must be unique per item.

import com.keenwrite.editors.TextDefinition;

import com.keenwrite.editors.TextEditor;

import com.keenwrite.editors.TextResource;

import com.keenwrite.editors.common.ScrollEventHandler;

import com.keenwrite.editors.common.VariableNameInjector;

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.events.spelling.LexiconLoadedEvent;

import com.keenwrite.io.MediaType;

import com.keenwrite.io.MediaTypeExtension;

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

import com.keenwrite.processors.r.RBootstrapController;

import com.keenwrite.service.events.Notifier;

import com.keenwrite.spelling.api.SpellChecker;

import com.keenwrite.spelling.impl.PermissiveSpeller;

import com.keenwrite.spelling.impl.SymSpellSpeller;

import com.keenwrite.typesetting.installer.TypesetterInstaller;

import com.keenwrite.ui.explorer.FilePickerFactory;

import com.keenwrite.ui.heuristics.DocumentStatistics;

import com.keenwrite.ui.outline.DocumentOutline;

import com.keenwrite.ui.spelling.TextEditorSpellChecker;

import com.keenwrite.util.GenericBuilder;

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

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

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.io.SysFile.toFile;

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

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 =

    new SimpleObjectProperty<>();

  /**

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

    new SimpleObjectProperty<>();

  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.addListener( ( c, o, n ) -> {

      if( o != null ) {

        removeProcessor( o );

      }

      if( n != null ) {

        mPreview.setBaseUri( n.getPath() );

        updateProcessors( n );

        process( n );

      }

    } );

    mTextEditor.set( createMarkdownEditor( DOCUMENT_DEFAULT ) );

    mDefinitionEditor.set( createDefinitionEditor( workspace ) );

    mVariableNameInjector = new VariableNameInjector( workspace );

    mRBootstrapController = new RBootstrapController(

      workspace, mDefinitionEditor.get()::getDefinitions

    );

    // If the user modifies the definitions, re-process the variables.

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

      final var textEditor = getTextEditor();

      if( textEditor.isMediaType( TEXT_R_MARKDOWN ) ) {

        mRBootstrapController.update();

      }

      process( textEditor );

    } );

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

        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 = toFile( Path.of( parentPath, eventUri.getPath() ) );

      }

    }

    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 mediaType = fromFilename( inputFile );

    // Only allow opening text files.

    if( !mediaType.isType( TEXT ) ) {

      return;

    }

    final var tab = createTab( inputFile );

    final var node = tab.getContent();

    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.get().toString();

          if( tabName.equalsIgnoreCase( fileName ) ) {

            final var node = tab.getContent();

            pane.getSelectionModel().select( tab );

            node.requestFocus();

            if( node instanceof TextEditor editor ) {

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

  static String get( final String key ) {

    return new File( get( "file.default." + suffix ) );

    // 256 is arbitrary; stack traces shouldn't be much larger.

    final var sb = new StringBuilder( 256 );

        .takeWhile( StatusEvent::filter )

        .limit( 15 )

  }

  /**

   * Returns {@code true} to allow the {@link StackTraceElement} to pass

   * through the filter.

   *

   * @param e The element to check against the filter.

   */

  private static boolean filter( final StackTraceElement e ) {

    final var clazz = e.getClassName();

    return !(clazz.contains( "org.renjin." ) ||

      clazz.contains( "sun." ) ||

      clazz.contains( "flexmark." ) ||

      clazz.contains( "java." )

    );

      final var prefix = ACTION_PREFIX + id + ".";

      final var text = prefix + "text";

      final var icon = prefix + "icon";

      final var accelerator = prefix + "accelerator";

      tooltip += " (" + mAccelerator.getDisplayText() + ')';

      addAction( "file.new", e -> actions.file_new() ),

      addAction( "file.open", e -> actions.file_open() ),

      addAction( "file.close", e -> actions.file_close() ),

      addAction( "file.close_all", e -> actions.file_close_all() ),

      addAction( "file.save", e -> actions.file_save() ),

      addAction( "file.save_as", e -> actions.file_save_as() ),

      addAction( "file.save_all", e -> actions.file_save_all() ),

      addAction( "file.export", e -> { } )

          addAction( "file.export.pdf", e -> actions.file_export_pdf() ),

          addAction( "file.export.pdf.dir", e -> actions.file_export_pdf_dir() ),

          addAction( "file.export.pdf.repeat", e -> actions.file_export_repeat() ),

          addAction( "file.export.html.dir", e -> actions.file_export_html_dir() ),

          addAction( "file.export.html_svg", e -> actions.file_export_html_svg() ),

          addAction( "file.export.html_tex", e -> actions.file_export_html_tex() ),

          addAction( "file.export.xhtml_tex", e -> actions.file_export_xhtml_tex() )

      addAction( "file.exit", e -> actions.file_exit() )

      addAction( "edit.undo", e -> actions.edit_undo() ),

      addAction( "edit.redo", e -> actions.edit_redo() ),

      addAction( "edit.cut", e -> actions.edit_cut() ),

      addAction( "edit.copy", e -> actions.edit_copy() ),

      addAction( "edit.paste", e -> actions.edit_paste() ),

      addAction( "edit.select_all", e -> actions.edit_select_all() ),

      addAction( "edit.find", e -> actions.edit_find() ),

      addAction( "edit.find_next", e -> actions.edit_find_next() ),

      addAction( "edit.find_prev", e -> actions.edit_find_prev() ),

      addAction( "edit.preferences", e -> actions.edit_preferences() )

      addAction( "format.bold", e -> actions.format_bold() ),

      addAction( "format.italic", e -> actions.format_italic() ),

      addAction( "format.monospace", e -> actions.format_monospace() ),

      addAction( "format.superscript", e -> actions.format_superscript() ),

      addAction( "format.subscript", e -> actions.format_subscript() ),

      addAction( "format.strikethrough", e -> actions.format_strikethrough() )

      addAction( "insert.blockquote", e -> actions.insert_blockquote() ),

      addAction( "insert.code", e -> actions.insert_code() ),

      addAction( "insert.fenced_code_block", e -> actions.insert_fenced_code_block() ),

      addAction( "insert.link", e -> actions.insert_link() ),

      addAction( "insert.image", e -> actions.insert_image() ),

      addAction( "insert.heading_1", e -> actions.insert_heading_1() ),

      addAction( "insert.heading_2", e -> actions.insert_heading_2() ),

      addAction( "insert.heading_3", e -> actions.insert_heading_3() ),

      addAction( "insert.unordered_list", e -> actions.insert_unordered_list() ),

      addAction( "insert.ordered_list", e -> actions.insert_ordered_list() ),

      addAction( "insert.horizontal_rule", e -> actions.insert_horizontal_rule() )

      addAction( "definition.insert", e -> actions.definition_autoinsert() ),

      addAction( "definition.create", e -> actions.definition_create() ),

      addAction( "definition.rename", e -> actions.definition_rename() ),

      addAction( "definition.delete", e -> actions.definition_delete() )

      addAction( "view.refresh", e -> actions.view_refresh() ),

      addAction( "view.preview", e -> actions.view_preview() ),

      addAction( "view.outline", e -> actions.view_outline() ),

      addAction( "view.statistics", e -> actions.view_statistics() ),

      addAction( "view.files", e -> actions.view_files() ),

      addAction( "view.menubar", e -> actions.view_menubar() ),

      addAction( "view.toolbar", e -> actions.view_toolbar() ),

      addAction( "view.statusbar", e -> actions.view_statusbar() ),

      addAction( "view.log", e -> actions.view_log() )

      addAction( "help.about", e -> actions.help_about() )

workspace.document.meta.desc=Keys must be alphabetic, values may use variables (e.g., '{{'book.title'}}').

workspace.document.meta.title=Pairs

workspace.editor=Editor

workspace.editor.autosave=Autosave

workspace.editor.autosave.desc=Amount of time to wait between saves, in seconds (0 means disabled).

workspace.editor.autosave.title=Timeout

workspace.typeset=Typesetting

workspace.typeset.context=ConTeXt

workspace.typeset.context.themes.path=Paths

workspace.typeset.context.themes.path.desc=Directory containing theme subdirectories.

workspace.typeset.context.themes.path.title=Themes

workspace.typeset.context.clean=Clean

workspace.typeset.context.clean.desc=Delete ancillary files after an unsuccessful export.

workspace.typeset.context.clean.title=Purge

workspace.typeset.context.fonts=Fonts

workspace.typeset.context.fonts.dir=Directory

workspace.typeset.context.fonts.dir.desc=Directory containing additional font files (OTF and TTF).

workspace.typeset.context.fonts.dir.title=Path

workspace.typeset.typography=Typography

workspace.typeset.typography.quotes=Quotation Marks

workspace.typeset.typography.quotes.desc=Export straight quotes and apostrophes as curled equivalents.

workspace.typeset.typography.quotes.title=Curl

workspace.r=R

workspace.r.script=Startup Script

workspace.r.script.desc=Script runs prior to executing R statements within the document.

workspace.r.dir=Working Directory

workspace.r.dir.desc=Value assigned to v$application$r$working$directory and usable in the startup script.

workspace.r.dir.title=Directory

workspace.r.delimiter.began=Delimiter Prefix

workspace.r.delimiter.began.desc=Prefix of expression that wraps inserted variables.

workspace.r.delimiter.began.title=Opening

workspace.r.delimiter.ended=Delimiter Suffix

workspace.r.delimiter.ended.desc=Suffix of expression that wraps inserted variables.

workspace.r.delimiter.ended.title=Closing

workspace.images=Images

workspace.images.dir=Absolute Directory

workspace.images.dir.desc=Path to search for local file system images.

workspace.images.dir.title=Directory

workspace.images.cache.desc=Path to store remotely retrieved images.

workspace.images.cache.title=Directory

workspace.images.order=Extensions

workspace.images.order.desc=Preferred order of image file types to embed, separated by spaces.

workspace.images.order.title=Extensions

workspace.images.resize=Resize

workspace.images.resize.desc=Scale images to fit the preview panel when resizing, automatically.

workspace.images.resize.title=Resize

workspace.images.server=Diagram Server

workspace.images.server.desc=Server used to generate diagrams (e.g., kroki.io).

workspace.images.server.title=Name

workspace.definition=Variable

workspace.definition.path=File name

workspace.definition.path.desc=Absolute path to interpolated string variables.

workspace.definition.path.title=Path

workspace.definition.delimiter.began=Delimiter Prefix

workspace.definition.delimiter.began.desc=Indicates when a variable name is starting.

workspace.definition.delimiter.began.title=Opening

workspace.definition.delimiter.ended=Delimiter Suffix

workspace.definition.delimiter.ended.desc=Indicates when a variable name is ending.

workspace.definition.delimiter.ended.title=Closing

workspace.ui.skin=Skins

workspace.ui.skin.selection=Bundled

workspace.ui.skin.selection.desc=Pre-packaged application style (default: Modena Light).

workspace.ui.skin.selection.title=Name

workspace.ui.skin.custom=Custom

workspace.ui.skin.custom.desc=User-defined JavaFX cascading stylesheet file.

workspace.ui.skin.custom.title=Path

workspace.ui.preview=Preview

workspace.ui.preview.stylesheet=Stylesheet

workspace.ui.preview.stylesheet.desc=User-defined HTML cascading stylesheet file.

workspace.ui.preview.stylesheet.title=Path