Dave Jarvis' Repositories

Home Files Commits Tags Clone

Repository:

git clone https://repo.autonoma.ca/repo/keenwrite.git

M docs/README.md

 See the following documents for more information:
 * [definitions.md](definitions.md) -- Definitions and interpolation
 * [variables.md](variables.md) -- Variable definitions and interpolation
 * [r.md](r.md) -- Call R functions within R Markdown documents
 * [svg.md](svg.md) -- Fix known issues with displaying SVG files

D docs/definitions.md

 # Introduction
 This document describes how to use the application.
 # Variable definitions
 Variable definitions provide a way to insert key names having associated values into a document. The variable names and values are declared inside an external file using the [YAML](http://www.yaml.org/) file format. Simply put, variables are written in the file as follows:
 ```
 key: value
 ```
 Any number of variables can be defined, in any order:
 ```
 key_1: Value 1
 key_2: Value 2
 ```
 Variables can reference other variables by bookending the key name within symbols:
 ```
 key: Value
 key_1: {{key}} 1
 key_2: {{key}} 2
 ```
 Variables can use a nested structure to help group related information:
 ```
 novel:
   title: Book Title
   author: Author Name
   isbn: 978-3-16-148410-0
 ```
 Use a period to reference nested keys, such as:
 ```
 novel:
   author: Author Name
 copyright:
   owner: {{novel.author}}
 ```
 Save the variable definitions in a file having an extension of `.yaml` or `.yml`.
 # Document editing
 The application's purpose is to completely separate the document's content from its presentation. To achieve this, documents are composed using a [plain text](http://spec.commonmark.org/0.28/) format.
 ## Create document
 Start a new document as follows:
 . Start the application.
 . Click **File → New** to create an empty document to edit.
 . Click **File → Open** to open a variable definition file.
 . Change **Source Files** to **Definition Files** to list definition files.
 . Browse to and select a file saved with a `.yaml` or `.yml` extension.
 . Click **Open**.
 The variable definitions appear in the variable definition pane under the heading of **Definitions**.
 ## Edit document
 Edit the document as normal. Notice how the preview pane updates as new content is added. The toolbar shows various icons that perform different formatting operations. Try them to see how they appear in the preview pane. Other operations not shown on the toolbar include:
 * Struck text (enclose the words within `~~` and `~~`)
 * Horizontal rule (use `---` on an otherwise empty line).
 The preview pane shows one way to interpret and format the document, but many other presentations are possible.
 ## Insert variable
 Let's assume that the variable definitions loaded into the application include:
 ```
 novel:
   title: Diary of {{novel.author}}
   author: Anne Frank
 ```
 To reference a variable, type in the key name enclosed within double braces, such as:
 ```
 The novel "{{novel.title}}" is one of the most widely read books in the world.
 ```
 The preview pane shows:
 > The novel "Diary of Anne Frank" is one of the most widely read books in the world.
 As it is laborious to type in variable names, it is possible to inject the variable name using autocomplete. Accomplish this as follows:
 . Create a new file.
 . Type in a partial variable value, such as **Dia**.
 . Press `Ctrl+Space` (hold down the `Control` key and tap the spacebar).
 The editor shows:
 ```
 {{novel.title}}
 ```
 The preview pane shows:
 ```
 Diary of Anne Frank
 ```
 The variable name is inserted into the document and the preview pane shows the variable's value.

M docs/r.md

 working directory where the R engine searches for source files.
 # YAML definitions
 # YAML variable definitions
 To see how variable definitions work in R, try the following:
 . Save the file as `definitions.yaml`.
 . Click **File → Open**.
 . Set **Source Files** to **Definition Files**.
 . Set **Source Files** to **Variable Files**.
 . Select `definitions.yaml`.
 . Click **Open**.
 ```
 This is because the application inserts definition reference names based
 This is because the application inserts variable reference names based
 on the type of file being edited. By default, the R engine does not have
 a function named `x` defined.
 The `x` function attempts to evaluate the expression defined by the YAML
 variable. This means that the YAML definitions can also include expressions
 variable. This means that the YAML variables can also include expressions
 that R is capable of evaluating.

A docs/variables.md

 # Introduction
 This document describes how to use the application.
 # Variable definitions
 Variable definitions provide a way to insert key names having associated values into a document. The variable names and values are declared inside an external file using the [YAML](http://www.yaml.org/) file format. Simply put, variables are written in the file as follows:
 ```
 key: value
 ```
 Any number of variables can be defined, in any order:
 ```
 key_1: Value 1
 key_2: Value 2
 ```
 Variables can reference other variables by bookending the key name within symbols:
 ```
 key: Value
 key_1: {{key}} 1
 key_2: {{key}} 2
 ```
 Variables can use a nested structure to help group related information:
 ```
 novel:
   title: Book Title
   author: Author Name
   isbn: 978-3-16-148410-0
 ```
 Use a period to reference nested keys, such as:
 ```
 novel:
   author: Author Name
 copyright:
   owner: {{novel.author}}
 ```
 Save the variable definitions in a file having an extension of `.yaml` or `.yml`.
 # Document editing
 The application's purpose is to completely separate the document's content from its presentation. To achieve this, documents are composed using a [plain text](http://spec.commonmark.org/0.28/) format.
 ## Create document
 Start a new document as follows:
 . Start the application.
 . Click **File → New** to create an empty document to edit.
 . Click **File → Open** to open a variable definition file.
 . Change **Source Files** to **Variable Files** to list variable definition files.
 . Browse to and select a file saved with a `.yaml` or `.yml` extension.
 . Click **Open**.
 The variable definitions appear in the variable definition pane under the heading of **Variables**.
 ## Edit document
 Edit the document as normal. Notice how the preview pane updates as new content is added. The toolbar shows various icons that perform different formatting operations. Try them to see how they appear in the preview pane. Other operations not shown on the toolbar include:
 * Struck text (enclose the words within `~~` and `~~`)
 * Horizontal rule (use `---` on an otherwise empty line).
 The preview pane shows one way to interpret and format the document, but many other presentations are possible.
 ## Insert variable
 Let's assume that the variable definitions loaded into the application include:
 ```
 novel:
   title: Diary of {{novel.author}}
   author: Anne Frank
 ```
 To reference a variable, type in the key name enclosed within double braces, such as:
 ```
 The novel "{{novel.title}}" is one of the most widely read books in the world.
 ```
 The preview pane shows:
 > The novel "Diary of Anne Frank" is one of the most widely read books in the world.
 As it is laborious to type in variable names, it is possible to inject the variable name using autocomplete. Accomplish this as follows:
 . Create a new file.
 . Type in a partial variable value, such as **Dia**.
 . Press `Ctrl+Space` (hold down the `Control` key and tap the spacebar).
 The editor shows:
 ```
 {{novel.title}}
 ```
 The preview pane shows:
 ```
 Diary of Anne Frank
 ```
 The variable name is inserted into the document and the preview pane shows the variable's value.

M src/main/java/com/keenwrite/MainPane.java

    * Renders the actively selected plain text editor tab.
    */
   private final HtmlPreview mHtmlPreview;
   /**
    * Provides an interactive document outline.
    */
   private final DocumentOutline mDocumentOutline = 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> mActiveTextEditor =
     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> mActiveDefinitionEditor =
     createActiveDefinitionEditor( mActiveTextEditor );
   /**
    * 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;
   /**
    * Called when the definition data is changed.
    */
   private final EventHandler<TreeModificationEvent<Event>> mTreeHandler =
     event -> {
       final var editor = mActiveDefinitionEditor.get();
       resolve( editor );
       process( getActiveTextEditor() );
       save( editor );
     };
   /**
    * 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;
     mHtmlPreview = new HtmlPreview( workspace );
     open( bin( 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 here. We want to close all the tabs to ensure each
         // is saved, but after they are closed, the workspace should still
         // retain the list of files that were open. If this line came after
         // closing, then restarting the application would list no files.
         mWorkspace.save();
         if( closeAll() ) {
           Platform.exit();
           System.exit( 0 );
+        }
         else {
           event.consume();
+        }
       } )
     );
     register( this );
+  }
   @Subscribe
   public void handle( final TextEditorFocusEvent event ) {
     mActiveTextEditor.set( event.get() );
+  }
   @Subscribe
   public void handle( final TextDefinitionFocusEvent event ) {
     mActiveDefinitionEditor.set( event.get() );
+  }
   /**
    * Typically called when a file name is clicked in the {@link HtmlPanel}.
+   *
    * @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 = getActiveTextEditor().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 = getActiveTextEditor().getTextArea();
       textArea.moveTo( event.getOffset() );
       textArea.requestFollowCaret();
       textArea.requestFocus();
     } );
+  }
   /**
    * TODO: Load divider positions from exported settings, see bin() 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.
+   *
    * @param file The file to open.
    */
   private void open( final File file ) {
     final var tab = createTab( file );
     final var node = tab.getContent();
     final var mediaType = MediaType.valueFrom( file );
     final var tabPane = obtainTabPane( mediaType );
     tab.setTooltip( createTooltip( file ) );
     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
       );
+    }
     getRecentFiles().add( file.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(
       ( mt, tp ) -> tp.getTabs().forEach( ( tab ) -> {
         final var node = tab.getContent();
         if( node instanceof TextEditor ) {
           save( ((TextEditor) node) );
+        }
       } )
     );
+  }
   /**
    * 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( getActiveTextEditor() );
+  }
   /**
    * Saves the active {@link TextEditor} under a new name.
+   *
    * @param file The new active editor {@link File} reference.
    */
   public void saveAs( final File file ) {
     assert file != null;
     final var editor = getActiveTextEditor();
     final var tab = getTab( editor );
     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 entry : mTabPanes.entrySet() ) {
       final var tabPane = entry.getValue();
       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 ) {
     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 = getActiveTextEditor();
     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 ) -> {
         tab.getTabPane().getTabs().remove( tab );
         close( 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 ) {
         mHtmlPreview.setBaseUri( n.getPath() );
         process( n );
+      }
     } );
     return editor;
+  }
   /**
    * Adds the HTML preview tab to its own, singular tab pane.
    */
   public void viewPreview() {
     viewTab( mHtmlPreview, TEXT_HTML, "HTML" );
+  }
   /**
    * Adds the document outline tab to its own, singular tab pane.
    */
   public void viewOutline() {
     viewTab( mDocumentOutline, APP_DOCUMENT_OUTLINE, "Outline" );
+  }
   private void viewTab(
     final Node node, final MediaType mediaType, final String name ) {
     final var tabPane = obtainTabPane( mediaType );
     for( final var tab : tabPane.getTabs() ) {
       if( tab.getContent() == node ) {
         return;
+      }
+    }
     tabPane.getTabs().add( createTab( name, node ) );
     addTabPane( tabPane );
+  }
   public void viewRefresh() {
     mHtmlPreview.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.values()
                     .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 {@link #mResolvedMap} is updated and the active
    * text editor is refreshed.
+   *
    * @param editor 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> editor ) {
     final var definitions = new SimpleObjectProperty<TextDefinition>();
     definitions.addListener( ( c, o, n ) -> {
       resolve( n == null ? createDefinitionEditor() : n );
       process( editor.get() );
     } );
     return definitions;
+  }
   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() )
     );
     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> bin( 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.
     final var bins = paths
       .stream()
       .collect(
         groupingBy( path -> bin.apply( MediaType.valueFrom( path ) ) )
       );
     bins.putIfAbsent( TEXT_YAML, List.of( DEFINITION_DEFAULT.toString() ) );
     bins.putIfAbsent( TEXT_PLAIN, List.of( DOCUMENT_DEFAULT.toString() ) );
     final var result = new ArrayList<File>( paths.size() );
     // Ensure that the same types are listed together (keep insertion order).
     bins.forEach( ( mediaType, files ) -> result.addAll(
       files.stream().map( File::new ).collect( Collectors.toList() ) )
     );
     return result;
+  }
   /**
    * Uses the given {@link TextDefinition} instance to update the
    * {@link #mResolvedMap}.
+   *
    * @param editor A non-null, possibly empty definition editor.
    */
   private void resolve( final TextDefinition editor ) {
     assert editor != null;
     final var tokens = createDefinitionTokens();
     final var operator = new YamlSigilOperator( tokens );
     final var map = new HashMap<String, String>();
     editor.toMap().forEach( ( k, v ) -> map.put( operator.entoken( k ), v ) );
     mResolvedMap.clear();
     mResolvedMap.putAll( editor.interpolate( map, tokens ) );
+  }
   /**
    * 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 that these are run from within the Swing event dispatch thread
     // so that the text editor thread is immediately freed for caret movement.
     // This means that the preview will have a slight delay when catching up
     // to the caret position.
     invokeLater( () -> {
       final var processor = mProcessors.getOrDefault( editor, IDENTITY );
       processor.apply( editor == null ? "" : editor.getText() );
       mHtmlPreview.scrollTo( CARET_ID );
     } );
+  }
   /**
    * 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 ) {
     return mTabPanes.computeIfAbsent(
       mediaType, ( mt ) -> createTabPane()
     );
+  }
   /**
    * 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 = mHtmlPreview.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 );
+  }
   public ProcessorContext createProcessorContext() {
     return createProcessorContext( NONE );
+  }
   public ProcessorContext createProcessorContext( final ExportFormat format ) {
     final var editor = getActiveTextEditor();
     return createProcessorContext(
       editor.getPath(), editor.getCaret(), format );
+  }
   /**
    * @param path  Used by {@link ProcessorFactory} to determine
    *              {@link Processor} type to create based on file type.
    * @param caret Used by {@link CaretExtension} to add ID attribute into
    *              preview document for scrollbar synchronization.
    * @return A new {@link ProcessorContext} to use when creating an instance of
    * {@link Processor}.
    */
   private ProcessorContext createProcessorContext(
     final Path path, final Caret caret, final ExportFormat format ) {
     return new ProcessorContext(
       mHtmlPreview, mResolvedMap, path, caret, format, mWorkspace
   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> mActiveTextEditor =
     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> mActiveDefinitionEditor =
     createActiveDefinitionEditor( mActiveTextEditor );
   /**
    * 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;
   /**
    * Called when the definition data is changed.
    */
   private final EventHandler<TreeModificationEvent<Event>> mTreeHandler =
     event -> {
       final var editor = mActiveDefinitionEditor.get();
       resolve( editor );
       process( getActiveTextEditor() );
       save( editor );
     };
   /**
    * 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 );
     open( bin( 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 here. We want to close all the tabs to ensure each
         // is saved, but after they are closed, the workspace should still
         // retain the list of files that were open. If this line came after
         // closing, then restarting the application would list no files.
         mWorkspace.save();
         if( closeAll() ) {
           Platform.exit();
           System.exit( 0 );
+        }
         else {
           event.consume();
+        }
       } )
     );
     register( this );
+  }
   @Subscribe
   public void handle( final TextEditorFocusEvent event ) {
     mActiveTextEditor.set( event.get() );
+  }
   @Subscribe
   public void handle( final TextDefinitionFocusEvent event ) {
     mActiveDefinitionEditor.set( event.get() );
+  }
   /**
    * Typically called when a file name is clicked in the {@link HtmlPanel}.
+   *
    * @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 = getActiveTextEditor().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 = getActiveTextEditor().getTextArea();
       textArea.moveTo( event.getOffset() );
       textArea.requestFollowCaret();
       textArea.requestFocus();
     } );
+  }
   /**
    * TODO: Load divider positions from exported settings, see bin() 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.
+   *
    * @param file The file to open.
    */
   private void open( final File file ) {
     final var tab = createTab( file );
     final var node = tab.getContent();
     final var mediaType = MediaType.valueFrom( file );
     final var tabPane = obtainTabPane( mediaType );
     tab.setTooltip( createTooltip( file ) );
     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
       );
+    }
     getRecentFiles().add( file.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(
       ( mt, tp ) -> tp.getTabs().forEach( ( tab ) -> {
         final var node = tab.getContent();
         if( node instanceof TextEditor ) {
           save( ((TextEditor) node) );
+        }
       } )
     );
+  }
   /**
    * 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( getActiveTextEditor() );
+  }
   /**
    * Saves the active {@link TextEditor} under a new name.
+   *
    * @param file The new active editor {@link File} reference.
    */
   public void saveAs( final File file ) {
     assert file != null;
     final var editor = getActiveTextEditor();
     final var tab = getTab( editor );
     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 entry : mTabPanes.entrySet() ) {
       final var tabPane = entry.getValue();
       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 ) {
     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 = getActiveTextEditor();
     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 ) -> {
         tab.getTabPane().getTabs().remove( tab );
         close( 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, get( "Pane.preview.title" ) );
+  }
   /**
    * Adds the document outline tab to its own, singular tab pane.
    */
   public void viewOutline() {
     viewTab( mOutline, APP_DOCUMENT_OUTLINE, get( "Pane.outline.title" ) );
+  }
   private void viewTab(
     final Node node, final MediaType mediaType, final String name ) {
     final var tabPane = obtainTabPane( mediaType );
     for( final var tab : tabPane.getTabs() ) {
       if( tab.getContent() == node ) {
         return;
+      }
+    }
     tabPane.getTabs().add( createTab( name, 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.values()
                     .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 {@link #mResolvedMap} is updated and the active
    * text editor is refreshed.
+   *
    * @param editor 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> editor ) {
     final var definitions = new SimpleObjectProperty<TextDefinition>();
     definitions.addListener( ( c, o, n ) -> {
       resolve( n == null ? createDefinitionEditor() : n );
       process( editor.get() );
     } );
     return definitions;
+  }
   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() )
     );
     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> bin( 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.
     final var bins = paths
       .stream()
       .collect(
         groupingBy( path -> bin.apply( MediaType.valueFrom( path ) ) )
       );
     bins.putIfAbsent( TEXT_YAML, List.of( DEFINITION_DEFAULT.toString() ) );
     bins.putIfAbsent( TEXT_PLAIN, List.of( DOCUMENT_DEFAULT.toString() ) );
     final var result = new ArrayList<File>( paths.size() );
     // Ensure that the same types are listed together (keep insertion order).
     bins.forEach( ( mediaType, files ) -> result.addAll(
       files.stream().map( File::new ).collect( Collectors.toList() ) )
     );
     return result;
+  }
   /**
    * Uses the given {@link TextDefinition} instance to update the
    * {@link #mResolvedMap}.
+   *
    * @param editor A non-null, possibly empty definition editor.
    */
   private void resolve( final TextDefinition editor ) {
     assert editor != null;
     final var tokens = createDefinitionTokens();
     final var operator = new YamlSigilOperator( tokens );
     final var map = new HashMap<String, String>();
     editor.toMap().forEach( ( k, v ) -> map.put( operator.entoken( k ), v ) );
     mResolvedMap.clear();
     mResolvedMap.putAll( editor.interpolate( map, tokens ) );
+  }
   /**
    * 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 that these are run from within the Swing event dispatch thread
     // so that the text editor thread is immediately freed for caret movement.
     // This means that the preview will have a slight delay when catching up
     // to the caret position.
     invokeLater( () -> {
       final var processor = mProcessors.getOrDefault( editor, IDENTITY );
       processor.apply( editor == null ? "" : editor.getText() );
       mPreview.scrollTo( CARET_ID );
     } );
+  }
   /**
    * 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 ) {
     return mTabPanes.computeIfAbsent(
       mediaType, ( mt ) -> createTabPane()
     );
+  }
   /**
    * 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 );
+  }
   public ProcessorContext createProcessorContext() {
     return createProcessorContext( NONE );
+  }
   public ProcessorContext createProcessorContext( final ExportFormat format ) {
     final var editor = getActiveTextEditor();
     return createProcessorContext(
       editor.getPath(), editor.getCaret(), format );
+  }
   /**
    * @param path  Used by {@link ProcessorFactory} to determine
    *              {@link Processor} type to create based on file type.
    * @param caret Used by {@link CaretExtension} to add ID attribute into
    *              preview document for scrollbar synchronization.
    * @return A new {@link ProcessorContext} to use when creating an instance of
    * {@link Processor}.
    */
   private ProcessorContext createProcessorContext(
     final Path path, final Caret caret, final ExportFormat format ) {
     return new ProcessorContext(
       mPreview, mResolvedMap, path, caret, format, mWorkspace
     );
+  }

M src/main/java/com/keenwrite/editors/definition/DefinitionEditor.java

 import com.keenwrite.editors.TextDefinition;
 import com.keenwrite.sigils.Tokens;
 import com.keenwrite.ui.tree.AltTreeView;
 import com.keenwrite.ui.tree.TreeItemConverter;
 import de.jensd.fx.glyphs.fontawesome.FontAwesomeIcon;
 import de.jensd.fx.glyphs.fontawesome.utils.FontAwesomeIconFactory;
    */
   private final DefinitionTreeItem<String> mTreeRoot = createRootTreeItem();
   /**
    * Converts a tree item value to and from a string..
    */
   private final TreeItemConverter mConverter = new TreeItemConverter();
   /**
    * Contains a view of the definitions.
    */
   private final TreeView<String> mTreeView = new TreeView<>( mTreeRoot );
   private final TreeView<String> mTreeView =
     new AltTreeView<>( mTreeRoot, mConverter );
   /**
     mTreeTransformer = treeTransformer;
     mTreeView.setEditable( true );
     mTreeView.setCellFactory( new TreeCellFactory() );
     //mTreeView.setCellFactory( new TreeCellFactory() );
     mTreeView.setContextMenu( createContextMenu() );
     mTreeView.addEventFilter( KEY_PRESSED, this::keyEventFilter );
     mTreeView.setShowRoot( false );
     mTreeView.focusedProperty().addListener( this::focused );
     getSelectionModel().setSelectionMode( MULTIPLE );

D src/main/java/com/keenwrite/editors/definition/FocusAwareTextFieldTreeCell.java

 /* Copyright 2020-2021 White Magic Software, Ltd. -- All rights reserved. */
 package com.keenwrite.editors.definition;
 import javafx.scene.Node;
 import javafx.scene.control.TextField;
 import javafx.scene.control.cell.TextFieldTreeCell;
 import javafx.util.StringConverter;
 /**
  * Responsible for fixing a focus lost bug in the JavaFX implementation.
  * See https://bugs.openjdk.java.net/browse/JDK-8089514 for details.
  * This implementation borrows from the official documentation on creating
  * tree views: https://docs.oracle.com/javafx/2/ui_controls/tree-view.htm
  */
 public class FocusAwareTextFieldTreeCell extends TextFieldTreeCell<String> {
   private TextField mTextField;
   public FocusAwareTextFieldTreeCell(
       final StringConverter<String> converter ) {
     super( converter );
+  }
   @Override
   public void startEdit() {
     super.startEdit();
     var textField = mTextField;
     if( textField == null ) {
       textField = createTextField();
+    }
     else {
       textField.setText( getItem() );
+    }
     setText( null );
     setGraphic( textField );
     textField.selectAll();
     textField.requestFocus();
     // When the focus is lost, commit the edit then close the input field.
     // This fixes the unexpected behaviour when user clicks away.
     textField.focusedProperty().addListener( ( l, o, n ) -> {
       if( !n ) {
         commitEdit( mTextField.getText() );
+      }
     } );
     mTextField = textField;
+  }
   @Override
   public void cancelEdit() {
     super.cancelEdit();
     setText( getItem() );
     setGraphic( getTreeItem().getGraphic() );
+  }
   @Override
   public void updateItem( String item, boolean empty ) {
     super.updateItem( item, empty );
     String text = null;
     Node graphic = null;
     if( !empty ) {
       if( isEditing() ) {
         final var textField = mTextField;
         if( textField != null ) {
           textField.setText( getString() );
+        }
         graphic = textField;
+      }
       else {
         text = getString();
         graphic = getTreeItem().getGraphic();
+      }
+    }
     setText( text );
     setGraphic( graphic );
+  }
   private TextField createTextField() {
     final var textField = new TextField( getString() );
     textField.setOnKeyReleased( t -> {
       switch( t.getCode() ) {
         case ENTER -> commitEdit( textField.getText() );
         case ESCAPE -> cancelEdit();
+      }
     } );
     return textField;
+  }
   private String getString() {
     return getConverter().toString( getItem() );
+  }
+}

D src/main/java/com/keenwrite/editors/definition/TreeCellFactory.java

 /* Copyright 2020-2021 White Magic Software, Ltd. -- All rights reserved. */
 package com.keenwrite.editors.definition;
 import javafx.collections.ObservableList;
 import javafx.scene.control.TreeCell;
 import javafx.scene.control.TreeItem;
 import javafx.scene.control.TreeView;
 import javafx.scene.input.ClipboardContent;
 import javafx.scene.input.DataFormat;
 import javafx.scene.input.DragEvent;
 import javafx.scene.input.MouseEvent;
 import javafx.util.Callback;
 import javafx.util.StringConverter;
 import java.util.Objects;
 import static com.keenwrite.io.MediaType.APP_JAVA_OBJECT;
 import static javafx.scene.input.TransferMode.MOVE;
 /**
  * Responsible for producing {@link TreeCell} instances that can be edited
  * and respond to drag and drop functionality.
  */
 public final class TreeCellFactory
     implements Callback<TreeView<String>, TreeCell<String>> {
   private static final String STYLE_CLASS_DROP_TARGET = "drop-target";
   private static final DataFormat JAVA_FORMAT =
       new DataFormat( APP_JAVA_OBJECT.toString() );
   private TreeItem<String> mDraggedTreeItem;
   private TreeCell<String> mTargetCell;
   /**
    * Constructs a new {@link TreeCell} manufacturing facility called when
    * a new {@link TreeItem} is added to one of the editor's {@link TreeView}s.
    */
   public TreeCellFactory() {
+  }
   @Override
   public TreeCell<String> call( final TreeView<String> treeView ) {
     final var cell = createTreeCell();
     cell.setOnDragDetected( event -> dragDetected( event, cell ) );
     cell.setOnDragOver( event -> dragOver( event, cell ) );
     cell.setOnDragDropped( event -> dragDropped( event, cell, treeView ) );
     cell.setOnDragDone( event -> dragClear() );
     return cell;
+  }
   private TreeCell<String> createTreeCell() {
     return new FocusAwareTextFieldTreeCell( createStringConverter() ) {
       @Override
       public void commitEdit( final String newValue ) {
         super.commitEdit( newValue );
         //mEditor.select( getTreeItem() );
         requestFocus();
+      }
     };
+  }
   private StringConverter<String> createStringConverter() {
     return new StringConverter<>() {
       @Override
       public String toString( final String object ) {
         return sanitize( object );
+      }
       @Override
       public String fromString( final String string ) {
         return sanitize( string );
+      }
       private String sanitize( final String string ) {
         return string == null ? "" : string;
+      }
     };
+  }
   /**
    * Drag start.
+   *
    * @param event    The drag start {@link MouseEvent}.
    * @param treeCell The cell being dragged.
    */
   private void dragDetected(
       final MouseEvent event, final TreeCell<String> treeCell ) {
     final var sourceItem = treeCell.getTreeItem();
     // Prevent dragging the root item.
     if( sourceItem != null && sourceItem.getParent() != null ) {
       final var dragboard = treeCell.startDragAndDrop( MOVE );
       final var clipboard = new ClipboardContent();
       clipboard.put( JAVA_FORMAT, sourceItem.getValue() );
       dragboard.setContent( clipboard );
       dragboard.setDragView( treeCell.snapshot( null, null ) );
       event.consume();
       mDraggedTreeItem = sourceItem;
+    }
+  }
   /**
    * Drag over another {@link TreeCell} instance.
+   *
    * @param event    The drag over {@link DragEvent}.
    * @param treeCell The cell dragged over.
    * @throws IllegalStateException Drag transfer "move" mode denied.
    */
   private void dragOver(
       final DragEvent event, final TreeCell<String> treeCell ) {
     if( event.getDragboard().hasContent( JAVA_FORMAT ) ) {
       final var thisItem = treeCell.getTreeItem();
       if( mDraggedTreeItem == null ||
           thisItem == null ||
           thisItem == mDraggedTreeItem ) {
         return;
+      }
       // Ignore dragging over the root item.
       if( mDraggedTreeItem.getParent() == null ) {
         dragClear();
         return;
+      }
       event.acceptTransferModes( MOVE );
       if( !Objects.equals( mTargetCell, treeCell ) ) {
         dragClear();
         mTargetCell = treeCell;
         mTargetCell.getStyleClass().add( STYLE_CLASS_DROP_TARGET );
+      }
+    }
+  }
   /**
    * Dragged item is dropped
+   *
    * @param event    The drag dropped {@link DragEvent}.
    * @param treeCell The cell dropped onto.
    */
   private void dragDropped( final DragEvent event,
                             final TreeCell<String> treeCell,
                             final TreeView<String> treeView ) {
     if( !event.getDragboard().hasContent( JAVA_FORMAT ) ) {
       return;
+    }
     final var sourceItem = mDraggedTreeItem;
     final var sourceItemParent = mDraggedTreeItem.getParent();
     final var targetItem = treeCell.getTreeItem();
     final var targetItemParent = targetItem.getParent();
     sourceItemParent.getChildren().remove( sourceItem );
     final ObservableList<TreeItem<String>> children;
     final int index;
     // Dropping onto a parent node makes the source item the first child.
     if( Objects.equals( sourceItemParent, targetItem ) ) {
       children = targetItem.getChildren();
       index = 0;
+    }
     else if( targetItemParent != null) {
       children = targetItemParent.getChildren();
       index = children.indexOf( targetItem ) + 1;
+    }
     else {
       children = sourceItemParent.getChildren();
       index = 0;
+    }
     children.add( index, sourceItem );
     treeView.getSelectionModel().clearSelection();
     treeView.getSelectionModel().select( sourceItem );
     // TODO: Notify a listener of the old and new tree item position.
     event.setDropCompleted( true );
+  }
   private void dragClear() {
     final var targetCell = mTargetCell;
     if( targetCell != null ) {
       targetCell.getStyleClass().remove( STYLE_CLASS_DROP_TARGET );
+    }
+  }
+}

M src/main/java/com/keenwrite/io/HttpMediaType.java

 package com.keenwrite.io;
 import javax.net.ssl.*;
 import java.net.MalformedURLException;
 import java.net.Socket;
 import java.net.URI;
 import java.net.URL;
 import java.net.http.HttpClient;
 import java.net.http.HttpRequest;
 import java.security.cert.X509Certificate;
 import static com.keenwrite.events.StatusEvent.clue;
  */
 public final class HttpMediaType {
   static {
     disableSSLVerification();
+  }
   private static final HttpClient HTTP_CLIENT = HttpClient
     return mediaType[ 0 ];
+  }
   // Method used for bypassing SSL verification
   private static void disableSSLVerification() {
     TrustManager[] trustAllCerts =
       new TrustManager[]{new X509ExtendedTrustManager() {
         @Override
         public void checkClientTrusted( X509Certificate[] chain,
                                         String authType,
                                         Socket socket ) {
+        }
         @Override
         public void checkServerTrusted( X509Certificate[] chain,
                                         String authType,
                                         Socket socket ) {
+        }
         @Override
         public void checkClientTrusted( X509Certificate[] chain,
                                         String authType,
                                         SSLEngine engine ) {
+        }
         @Override
         public void checkServerTrusted( X509Certificate[] chain,
                                         String authType,
                                         SSLEngine engine ) {
+        }
         @Override
         public java.security.cert.X509Certificate[] getAcceptedIssuers() {
           return null;
+        }
         @Override
         public void checkClientTrusted(
           X509Certificate[] certs, String authType ) {
+        }
         @Override
         public void checkServerTrusted(
           X509Certificate[] certs, String authType ) {
+        }
       }};
     try {
       final var context = SSLContext.getInstance( "SSL" );
       context.init( null, trustAllCerts, new java.security.SecureRandom() );
       HttpsURLConnection.setDefaultSSLSocketFactory( context.getSocketFactory() );
       HttpsURLConnection.setDefaultHostnameVerifier( ( hostname, session ) -> true );
     } catch( final Exception ex ) {
       clue( ex );
+    }
+  }
+}

M src/main/java/com/keenwrite/preview/HtmlPreview.java

 package com.keenwrite.preview;
 import com.keenwrite.Constants;
 import com.keenwrite.preferences.LocaleProperty;
 import com.keenwrite.preferences.Workspace;
 import javafx.application.Platform;
 import javafx.beans.property.DoubleProperty;
 import javafx.beans.property.StringProperty;
 import javafx.embed.swing.SwingNode;
 import org.xhtmlrenderer.render.Box;
 import org.xhtmlrenderer.swing.SwingReplacedElementFactory;
 import javax.swing.*;
 import java.awt.*;
 import java.net.URL;
 import java.nio.file.Path;
 import java.util.Locale;
 import static com.keenwrite.Constants.*;
 import static com.keenwrite.Messages.get;
 import static com.keenwrite.events.StatusEvent.clue;
 import static com.keenwrite.preferences.WorkspaceKeys.*;
 import static java.lang.Math.max;
 import static java.lang.String.format;
 import static java.lang.Thread.sleep;
 import static javafx.application.Platform.runLater;
 import static javafx.scene.CacheHint.SPEED;
 import static javax.swing.SwingUtilities.invokeLater;
 /**
  * Responsible for parsing an HTML document.
  */
 public final class HtmlPreview extends SwingNode {
   /**
    * The order is important: Swing factory will replace SVG images with
    * a blank image, which will cause the chained factory to cache the image
    * and exit. Instead, the SVG must execute first to rasterize the content.
    * Consequently, the chained factory must maintain insertion order.
    */
   private static final ChainedReplacedElementFactory FACTORY
     = new ChainedReplacedElementFactory(
     new SvgReplacedElementFactory(),
     new SwingReplacedElementFactory()
   );
   /**
    * Used to populate the {@link #HTML_HEAD} with stylesheet file references.
    */
   private static final String HTML_STYLESHEET =
     "<link rel='stylesheet' href='%s'/>";
   /**
    * Render CSS using points (pt) not pixels (px) to reduce the chance of
    * poor rendering. The {@link #head()} method fills out the placeholders.
    * When the user has not set a locale, only one stylesheet is added to
    * the document.
    * <p>
    * Do not use points, only pixels here.
    * </p>
    */
   private static final String HTML_HEAD =
     """
       <!doctype html>
       <html lang='%s'><head><title> </title><meta charset='utf-8'/>
       %s%s<style>body{font-family:'%s';font-size: %dpx;}</style>
       <base href='%s'/></head><body>
       """;
   private static final String HTML_TAIL = "</body></html>";
   private static final URL HTML_STYLE_PREVIEW = toUrl( STYLESHEET_PREVIEW );
   /**
    * The buffer is reused so that previous memory allocations need not repeat.
    */
   private final StringBuilder mHtmlDocument = new StringBuilder( 65536 );
   private HtmlPanel mView;
   private JScrollPane mScrollPane;
   private String mBaseUriPath = "";
   /**
    * Populates {@link Constants#STYLESHEET_PREVIEW_LOCALE} for stylesheet.
    */
   private URL mLocaleUrl;
   private final Workspace mWorkspace;
   /**
    * Creates a new preview pane that can scroll to the caret position within the
    * document.
+   *
    * @param workspace Contains locale and font size information.
    */
   public HtmlPreview( final Workspace workspace ) {
     mWorkspace = workspace;
     mLocaleUrl = toUrl( getLocale() );
     // Attempts to prevent a flash of black un-styled content upon load.
     setStyle( "-fx-background-color: white;" );
     invokeLater( () -> {
       mView = new HtmlPanel();
       mScrollPane = new JScrollPane( mView );
       // Enabling the cache attempts to prevent black flashes when resizing.
       setCache( true );
       setCacheHint( SPEED );
       setContent( mScrollPane );
       final var context = mView.getSharedContext();
       final var textRenderer = context.getTextRenderer();
       context.setReplacedElementFactory( FACTORY );
       textRenderer.setSmoothingThreshold( 0 );
       localeProperty().addListener( ( c, o, n ) -> {
         mLocaleUrl = toUrl( getLocale() );
         rerender();
       } );
       fontFamilyProperty().addListener( ( c, o, n ) -> rerender() );
       fontSizeProperty().addListener( ( c, o, n ) -> rerender() );
     } );
+  }
   /**
    * Updates the internal HTML source shown in the preview pane.
+   *
    * @param html The new HTML document to display.
    */
   public void render( final String html ) {
     mView.render( decorate( html ), getBaseUri() );
+  }
   /**
    * Clears the caches then rerenders the content.
    */
   public void refresh() {
     FACTORY.clearCache();
     rerender();
+  }
   private void rerender() {
     render( mHtmlDocument.toString() );
+  }
   /**
    * Attaches the HTML head prefix and HTML tail suffix to the given HTML
    * string.
+   *
    * @param html The HTML to adorn with opening and closing tags.
    * @return A complete HTML document, ready for rendering.
    */
   private String decorate( final String html ) {
     mHtmlDocument.setLength( 0 );
     mHtmlDocument.append( head() );
     mHtmlDocument.append( html );
     mHtmlDocument.append( tail() );
     return mHtmlDocument.toString();
+  }
   private String head() {
     return format(
       HTML_HEAD,
       getLocale().getLanguage(),
       format( HTML_STYLESHEET, HTML_STYLE_PREVIEW ),
       mLocaleUrl == null ? "" : format( HTML_STYLESHEET, mLocaleUrl ),
       getFontFamily(),
       (int) (getFontSize() * (1 + 1 / 3f)),
       mBaseUriPath
     );
+  }
   private String tail() {
     return HTML_TAIL;
+  }
   /**
    * Clears the preview pane by rendering an empty string.
    */
   public void clear() {
     render( "" );
+  }
   /**
    * Sets the base URI to the containing directory the file being edited.
+   *
    * @param path The path to the file being edited.
    */
   public void setBaseUri( final Path path ) {
     final var parent = path.getParent();
     mBaseUriPath = parent == null ? "" : parent.toUri().toString();
+  }
   /**
    * Scrolls to the closest element matching the given identifier without
    * waiting for the document to be ready.
+   *
    * @param id Scroll the preview pane to this unique paragraph identifier.
    */
   public void scrollTo( final String id ) {
     final Runnable scrollToBox = () -> {
       int iter = 0;
       Box box = null;
       while( iter++ < 3 && ((box = mView.getBoxById( id )) == null) ) {
         try {
           sleep( 10 );
         } catch( final Exception ex ) {
           clue( ex );
+        }
+      }
       scrollTo( box );
     };
     if( Platform.isFxApplicationThread() ) {
       scrollToBox.run();
+    }
     else {
       runLater( scrollToBox );
+    }
+  }
   /**
    * Scrolls to the location specified by the {@link Box} that corresponds
    * to a point somewhere in the preview pane. If there is no caret, then
    * this will not change the scroll position. Changing the scroll position
    * to the top if the {@link Box} instance is {@code null} will result in
    * jumping around a lot and inconsistent synchronization issues.
+   *
    * @param box The rectangular region containing the caret, or {@code null}
    *            if the HTML does not have a caret.
    */
   private void scrollTo( final Box box ) {
     if( box != null ) {
       scrollTo( createPoint( box ) );
+    }
+  }
   private void scrollTo( final Point point ) {
     invokeLater( () -> {
       mView.scrollTo( point );
       getScrollPane().repaint();
     } );
+  }
   /**
    * Creates a {@link Point} to use as a reference for scrolling to the area
    * described by the given {@link Box}. The {@link Box} coordinates are used
    * to populate the {@link Point}'s location, with minor adjustments for
    * vertical centering.
+   *
    * @param box The {@link Box} that represents a scrolling anchor reference.
    * @return A coordinate suitable for scrolling to.
    */
   private Point createPoint( final Box box ) {
     assert box != null;
     // Scroll back up by half the height of the scroll bar to keep the typing
     // area within the view port. Otherwise the view port will have jumped too
     // high up and the most recently typed letters won't be visible.
     int y = max( box.getAbsY() - getVerticalScrollBarHeight() / 2, 0 );
     int x = box.getAbsX();
     if( !box.getStyle().isInline() ) {
       final var margin = box.getMargin( mView.getLayoutContext() );
       y += margin.top();
       x += margin.left();
+    }
     return new Point( x, y );
+  }
   private String getBaseUri() {
     return mBaseUriPath;
+  }
   private JScrollPane getScrollPane() {
     return mScrollPane;
+  }
   public JScrollBar getVerticalScrollBar() {
     return getScrollPane().getVerticalScrollBar();
+  }
   private int getVerticalScrollBarHeight() {
     return getVerticalScrollBar().getHeight();
+  }
   /**
    * Returns the ISO 639 alpha-2 or alpha-3 language code followed by a hyphen
    * followed by the ISO 15924 alpha-4 script code, followed by an ISO 3166
    * alpha-2 country code or UN M.49 numeric-3 area code. For example, this
    * could return "en-Latn-CA" for Canadian English written in the Latin
    * character set.
+   *
    * @return Unique identifier for language and country.
    */
   private static URL toUrl( final Locale locale ) {
     return toUrl(
       get(
         sSettings.getSetting( STYLESHEET_PREVIEW_LOCALE, "" ),
         locale.getLanguage(),
         locale.getScript(),
         locale.getCountry()
+      )
     );
+  }
   private static URL toUrl( final String path ) {
     return HtmlPreview.class.getResource( path );
+  }
   private Locale getLocale() {
     return localeProperty().toLocale();
+  }
   private LocaleProperty localeProperty() {
     return mWorkspace.localeProperty( KEY_LANGUAGE_LOCALE );
+  }
   private String getFontFamily() {
     return fontFamilyProperty().get();
+  }
   private StringProperty fontFamilyProperty() {
     return mWorkspace.stringProperty( KEY_UI_FONT_PREVIEW_NAME );
+  }
   private double getFontSize() {
     return fontSizeProperty().get();
+  }
   /**
    * Returns the font size in points.
 import com.keenwrite.preferences.LocaleProperty;
 import com.keenwrite.preferences.Workspace;
 import javafx.application.Platform;
 import javafx.beans.property.DoubleProperty;
 import javafx.beans.property.StringProperty;
 import javafx.embed.swing.SwingNode;
 import org.xhtmlrenderer.render.Box;
 import org.xhtmlrenderer.swing.SwingReplacedElementFactory;
 import javax.swing.*;
 import java.awt.*;
 import java.net.URL;
 import java.nio.file.Path;
 import java.util.Locale;
 import static com.keenwrite.Constants.*;
 import static com.keenwrite.Messages.get;
 import static com.keenwrite.events.StatusEvent.clue;
 import static com.keenwrite.preferences.WorkspaceKeys.*;
 import static java.lang.Math.max;
 import static java.lang.String.format;
 import static java.lang.Thread.sleep;
 import static javafx.application.Platform.runLater;
 import static javafx.scene.CacheHint.SPEED;
 import static javax.swing.SwingUtilities.invokeLater;
 /**
  * Responsible for parsing an HTML document.
  */
 public final class HtmlPreview extends SwingNode {
   /**
    * The order is important: Swing factory will replace SVG images with
    * a blank image, which will cause the chained factory to cache the image
    * and exit. Instead, the SVG must execute first to rasterize the content.
    * Consequently, the chained factory must maintain insertion order.
    */
   private static final ChainedReplacedElementFactory FACTORY
     = new ChainedReplacedElementFactory(
     new SvgReplacedElementFactory(),
     new SwingReplacedElementFactory()
   );
   /**
    * Used to populate the {@link #HTML_HEAD} with stylesheet file references.
    */
   private static final String HTML_STYLESHEET =
     "<link rel='stylesheet' href='%s'>";
   private static final String HTML_BASE =
     "<base href='%s'>";
   /**
    * Render CSS using points (pt) not pixels (px) to reduce the chance of
    * poor rendering. The {@link #generateHead()} method fills placeholders.
    * When the user has not set a locale, only one stylesheet is added to
    * the document. In order, the placeholders are as follows:
    * <ol>
    * <li>%s --- language</li>
    * <li>%s --- default stylesheet</li>
    * <li>%s --- language-specific stylesheet</li>
    * <li>%s --- font family</li>
    * <li>%d --- font size (must be pixels, not points due to bug)</li>
    * <li>%s --- base href</li>
    * </p>
    */
   private static final String HTML_HEAD =
     """
       <!doctype html>
       <html lang='%s'><head><title> </title><meta charset='utf-8'>
       %s%s<style>body{font-family:'%s';font-size: %dpx;}</style>%s</head><body>
       """;
   private static final String HTML_TAIL = "</body></html>";
   private static final URL HTML_STYLE_PREVIEW = toUrl( STYLESHEET_PREVIEW );
   /**
    * Reusing this buffer prevents repetitious memory re-allocations.
    */
   private final StringBuilder mDocument = new StringBuilder( 65536 );
   private HtmlPanel mView;
   private JScrollPane mScrollPane;
   private String mBaseUriPath = "";
   private String mHead = "";
   private final Workspace mWorkspace;
   /**
    * Creates a new preview pane that can scroll to the caret position within the
    * document.
+   *
    * @param workspace Contains locale and font size information.
    */
   public HtmlPreview( final Workspace workspace ) {
     mWorkspace = workspace;
     // Attempts to prevent a flash of black un-styled content upon load.
     setStyle( "-fx-background-color: white;" );
     invokeLater( () -> {
       mHead = generateHead();
       mView = new HtmlPanel();
       mScrollPane = new JScrollPane( mView );
       // Enabling the cache attempts to prevent black flashes when resizing.
       setCache( true );
       setCacheHint( SPEED );
       setContent( mScrollPane );
       final var context = mView.getSharedContext();
       final var textRenderer = context.getTextRenderer();
       context.setReplacedElementFactory( FACTORY );
       textRenderer.setSmoothingThreshold( 0 );
       localeProperty().addListener( ( c, o, n ) -> rerender() );
       fontFamilyProperty().addListener( ( c, o, n ) -> rerender() );
       fontSizeProperty().addListener( ( c, o, n ) -> rerender() );
     } );
+  }
   /**
    * Updates the internal HTML source shown in the preview pane.
+   *
    * @param html The new HTML document to display.
    */
   public void render( final String html ) {
     mView.render( decorate( html ), getBaseUri() );
+  }
   /**
    * Clears the caches then rerenders the content.
    */
   public void refresh() {
     FACTORY.clearCache();
     rerender();
+  }
   /**
    * Recomputes the HTML head then renders the document.
    */
   private void rerender() {
     mHead = generateHead();
     render( mDocument.toString() );
+  }
   /**
    * Attaches the HTML head prefix and HTML tail suffix to the given HTML
    * string.
+   *
    * @param html The HTML to adorn with opening and closing tags.
    * @return A complete HTML document, ready for rendering.
    */
   private String decorate( final String html ) {
     mDocument.setLength( 0 );
     mDocument.append( html );
     // Head and tail must be separate from document due to re-rendering.
     return mHead + mDocument.toString() + HTML_TAIL;
+  }
   /**
    * Called when settings are changed that affect the HTML document preamble.
    * This is a minor performance optimization to avoid generating the head
    * each time that the document itself changes.
+   *
    * @return A new doctype and HTML {@code head} element.
    */
   private String generateHead() {
     final var locale = getLocale();
     final var url = toUrl( locale );
     final var base = getBaseUri();
     // Point sizes are converted to pixels because of a rendering bug.
     return format(
       HTML_HEAD,
       locale.getLanguage(),
       format( HTML_STYLESHEET, HTML_STYLE_PREVIEW ),
       url == null ? "" : format( HTML_STYLESHEET, url ),
       getFontFamily(),
       (int) (getFontSize() * (1 + 1 / 3f)),
       base.isBlank() ? "" : format( HTML_BASE, base )
     );
+  }
   /**
    * Clears the preview pane by rendering an empty string.
    */
   public void clear() {
     render( "" );
+  }
   /**
    * Sets the base URI to the containing directory the file being edited.
+   *
    * @param path The path to the file being edited.
    */
   public void setBaseUri( final Path path ) {
     final var parent = path.getParent();
     mBaseUriPath = parent == null ? "" : parent.toUri().toString();
+  }
   /**
    * Scrolls to the closest element matching the given identifier without
    * waiting for the document to be ready.
+   *
    * @param id Scroll the preview pane to this unique paragraph identifier.
    */
   public void scrollTo( final String id ) {
     final Runnable scrollToBox = () -> {
       int iter = 0;
       Box box = null;
       while( iter++ < 3 && ((box = mView.getBoxById( id )) == null) ) {
         try {
           sleep( 10 );
         } catch( final Exception ex ) {
           clue( ex );
+        }
+      }
       scrollTo( box );
     };
     if( Platform.isFxApplicationThread() ) {
       scrollToBox.run();
+    }
     else {
       runLater( scrollToBox );
+    }
+  }
   /**
    * Scrolls to the location specified by the {@link Box} that corresponds
    * to a point somewhere in the preview pane. If there is no caret, then
    * this will not change the scroll position. Changing the scroll position
    * to the top if the {@link Box} instance is {@code null} will result in
    * jumping around a lot and inconsistent synchronization issues.
+   *
    * @param box The rectangular region containing the caret, or {@code null}
    *            if the HTML does not have a caret.
    */
   private void scrollTo( final Box box ) {
     if( box != null ) {
       scrollTo( createPoint( box ) );
+    }
+  }
   private void scrollTo( final Point point ) {
     invokeLater( () -> {
       mView.scrollTo( point );
       getScrollPane().repaint();
     } );
+  }
   /**
    * Creates a {@link Point} to use as a reference for scrolling to the area
    * described by the given {@link Box}. The {@link Box} coordinates are used
    * to populate the {@link Point}'s location, with minor adjustments for
    * vertical centering.
+   *
    * @param box The {@link Box} that represents a scrolling anchor reference.
    * @return A coordinate suitable for scrolling to.
    */
   private Point createPoint( final Box box ) {
     assert box != null;
     // Scroll back up by half the height of the scroll bar to keep the typing
     // area within the view port. Otherwise the view port will have jumped too
     // high up and the most recently typed letters won't be visible.
     int y = max( box.getAbsY() - getVerticalScrollBarHeight() / 2, 0 );
     int x = box.getAbsX();
     if( !box.getStyle().isInline() ) {
       final var margin = box.getMargin( mView.getLayoutContext() );
       y += margin.top();
       x += margin.left();
+    }
     return new Point( x, y );
+  }
   private String getBaseUri() {
     return mBaseUriPath;
+  }
   private JScrollPane getScrollPane() {
     return mScrollPane;
+  }
   public JScrollBar getVerticalScrollBar() {
     return getScrollPane().getVerticalScrollBar();
+  }
   private int getVerticalScrollBarHeight() {
     return getVerticalScrollBar().getHeight();
+  }
   /**
    * Returns the ISO 639 alpha-2 or alpha-3 language code followed by a hyphen
    * followed by the ISO 15924 alpha-4 script code, followed by an ISO 3166
    * alpha-2 country code or UN M.49 numeric-3 area code. For example, this
    * could return "en-Latn-CA" for Canadian English written in the Latin
    * character set.
+   *
    * @return Unique identifier for language and country.
    */
   private static URL toUrl( final Locale locale ) {
     return toUrl(
       get(
         sSettings.getSetting( STYLESHEET_PREVIEW_LOCALE, "" ),
         locale.getLanguage(),
         locale.getScript(),
         locale.getCountry()
+      )
     );
+  }
   private static URL toUrl( final String path ) {
     return HtmlPreview.class.getResource( path );
+  }
   private Locale getLocale() {
     return localeProperty().toLocale();
+  }
   private LocaleProperty localeProperty() {
     return mWorkspace.localeProperty( KEY_LANGUAGE_LOCALE );
+  }
   private String getFontFamily() {
     return fontFamilyProperty().get();
+  }
   private StringProperty fontFamilyProperty() {
     return mWorkspace.stringProperty( KEY_UI_FONT_PREVIEW_NAME );
+  }
   private double getFontSize() {
     return fontSizeProperty().get();
+  }
   /**
    * Returns the font size in points.
+   *
    * @return The user-defined font size (in pt).
    */

A src/main/java/com/keenwrite/ui/tree/AltTreeCell.java

 /* Copyright 2020-2021 White Magic Software, Ltd. -- All rights reserved. */
 package com.keenwrite.ui.tree;
 import javafx.beans.property.Property;
 import javafx.beans.property.SimpleStringProperty;
 import javafx.beans.value.ChangeListener;
 import javafx.beans.value.ObservableValue;
 import javafx.event.EventHandler;
 import javafx.scene.control.TextField;
 import javafx.scene.control.cell.TextFieldTreeCell;
 import javafx.scene.input.KeyEvent;
 import javafx.util.StringConverter;
 import static javafx.application.Platform.runLater;
 import static javafx.scene.input.KeyCode.ENTER;
 import static javafx.scene.input.KeyCode.TAB;
 import static javafx.scene.input.KeyEvent.KEY_RELEASED;
 /**
  * Responsible for enhancing the existing cell behaviour with fairly common
  * functionality, including commit on focus loss and Enter to commit.
+ *
  * @param <T> The type of data stored by the tree.
  */
 public class AltTreeCell<T> extends TextFieldTreeCell<T> {
   private final KeyHandler mKeyHandler = new KeyHandler();
   private final Property<String> mInputText = new SimpleStringProperty();
   private FocusListener mFocusListener;
   public AltTreeCell( final StringConverter<T> converter ) {
     super( converter );
     assert converter != null;
     // When the text field is added as the graphics context, we hook into
     // the changed value to get a handle on the text field. From there it is
     // possible to add change the keyboard and focus behaviours.
     graphicProperty().addListener( ( c, o, n ) -> {
       if( o instanceof TextField ) {
         o.removeEventHandler( KEY_RELEASED, mKeyHandler );
         o.focusedProperty().removeListener( mFocusListener );
+      }
       if( n instanceof TextField ) {
         n.addEventFilter( KEY_RELEASED, mKeyHandler );
         final var input = (TextField) n;
         mInputText.bind( input.textProperty() );
         mFocusListener = new FocusListener( input );
         n.focusedProperty().addListener( mFocusListener );
+      }
     } );
+  }
   private void commitEdit() {
     commitEdit( getConverter().fromString( mInputText.getValue() ) );
+  }
   /**
    * Responsible for accepting the text when users press the Enter or Tab key.
    */
   private class KeyHandler implements EventHandler<KeyEvent> {
     @Override
     public void handle( final KeyEvent event ) {
       if( event.getCode() == ENTER || event.getCode() == TAB ) {
         commitEdit();
         event.consume();
+      }
+    }
+  }
   /**
    * Responsible for committing edits when focus is lost. This will also
    * deselect the input field when focus is gained so that typing text won't
    * overwrite the entire existing text.
    */
   private class FocusListener implements ChangeListener<Boolean> {
     private final TextField mInput;
     private FocusListener( final TextField input ) {
       mInput = input;
+    }
     @Override
     public void changed(
       final ObservableValue<? extends Boolean> c,
       final Boolean endedFocus, final Boolean beganFocus ) {
       if( beganFocus ) {
         runLater( mInput::deselect );
+      }
       else if( endedFocus ) {
         commitEdit();
+      }
+    }
+  }
+}

A src/main/java/com/keenwrite/ui/tree/AltTreeCellFactory.java

 /* Copyright 2020-2021 White Magic Software, Ltd. -- All rights reserved. */
 package com.keenwrite.ui.tree;
 import javafx.scene.control.TreeCell;
 import javafx.scene.control.TreeView;
 import javafx.util.Callback;
 import javafx.util.StringConverter;
 //import javafx.collections.ObservableList;
 //import javafx.scene.control.TreeCell;
 //import javafx.scene.control.TreeItem;
 //import javafx.scene.control.TreeView;
 //import javafx.scene.input.ClipboardContent;
 //import javafx.scene.input.DataFormat;
 //import javafx.scene.input.DragEvent;
 //import javafx.scene.input.MouseEvent;
 //import javafx.util.StringConverter;
 //import java.util.Objects;
 //import static javafx.scene.input.TransferMode.MOVE;
 /**
  * Responsible for creating new {@link TreeCell} instances.
+ *
  * @param <T> The data type stored in the tree.
  */
 public class AltTreeCellFactory<T>
   implements Callback<TreeView<T>, TreeCell<T>> {
   private final StringConverter<T> mConverter;
   public AltTreeCellFactory( final StringConverter<T> converter ) {
     mConverter = converter;
+  }
   @Override
   public TreeCell<T> call( final TreeView<T> treeView ) {
     return new AltTreeCell<>( mConverter );
+  }
 //  private static final String STYLE_CLASS_DROP_TARGET = "drop-target";
 //  private static final DataFormat JAVA_FORMAT =
 //      new DataFormat( APP_JAVA_OBJECT.toString() );
 //
 //  private TreeItem<String> mDraggedTreeItem;
 //  private TreeCell<String> mTargetCell;
 //
 //  @Override
 //  public TreeCell<String> call( final TreeView<String> treeView ) {
 //    final var cell = createTreeCell();
 //
 //    cell.setOnDragDetected( event -> dragDetected( event, cell ) );
 //    cell.setOnDragOver( event -> dragOver( event, cell ) );
 //    cell.setOnDragDropped( event -> dragDropped( event, cell, treeView ) );
 //    cell.setOnDragDone( event -> dragClear() );
 //
 //    return cell;
 //  }
 //
 //  private TreeCell<String> createTreeCell() {
 //  }
 //
 //  /**
 //   * Drag start.
 //   *
 //   * @param event    The drag start {@link MouseEvent}.
 //   * @param treeCell The cell being dragged.
 //   */
 //private void dragDetected(
 //  final MouseEvent event, final TreeCell<String> treeCell ) {
 //  final var sourceItem = treeCell.getTreeItem();
 //
 //  // Prevent dragging the root item.
 //  if( sourceItem != null && sourceItem.getParent() != null ) {
 //    final var dragboard = treeCell.startDragAndDrop( MOVE );
 //    final var clipboard = new ClipboardContent();
 //    clipboard.put( JAVA_FORMAT, sourceItem.getValue() );
 //    dragboard.setContent( clipboard );
 //    dragboard.setDragView( treeCell.snapshot( null, null ) );
 //    event.consume();
 //
 //    mDraggedTreeItem = sourceItem;
 //  }
 //}
 //
 //  /**
 //   * Drag over another {@link TreeCell} instance.
 //   *
 //   * @param event    The drag over {@link DragEvent}.
 //   * @param treeCell The cell dragged over.
 //   * @throws IllegalStateException Drag transfer "move" mode denied.
 //   */
 //  private void dragOver(
 //    final DragEvent event, final TreeCell<String> treeCell ) {
 //    if( event.getDragboard().hasContent( JAVA_FORMAT ) ) {
 //      final var thisItem = treeCell.getTreeItem();
 //
 //      if( mDraggedTreeItem == null ||
 //        thisItem == null ||
 //        thisItem == mDraggedTreeItem ) {
 //        return;
 //      }
 //
 //      // Ignore dragging over the root item.
 //      if( mDraggedTreeItem.getParent() == null ) {
 //        dragClear();
 //        return;
 //      }
 //
 //      event.acceptTransferModes( MOVE );
 //
 //      if( !Objects.equals( mTargetCell, treeCell ) ) {
 //        dragClear();
 //        mTargetCell = treeCell;
 //        mTargetCell.getStyleClass().add( STYLE_CLASS_DROP_TARGET );
 //      }
 //    }
 //  }
 //
 //  /**
 //   * Dragged item is dropped
 //   *
 //   * @param event    The drag dropped {@link DragEvent}.
 //   * @param treeCell The cell dropped onto.
 //   */
 //  private void dragDropped( final DragEvent event,
 //                            final TreeCell<String> treeCell,
 //                            final TreeView<String> treeView ) {
 //    if( !event.getDragboard().hasContent( JAVA_FORMAT ) ) {
 //      return;
 //    }
 //
 //    final var sourceItem = mDraggedTreeItem;
 //    final var sourceItemParent = mDraggedTreeItem.getParent();
 //    final var targetItem = treeCell.getTreeItem();
 //    final var targetItemParent = targetItem.getParent();
 //
 //    sourceItemParent.getChildren().remove( sourceItem );
 //
 //    final ObservableList<TreeItem<String>> children;
 //    final int index;
 //
 //    // Dropping onto a parent node makes the source item the first child.
 //    if( Objects.equals( sourceItemParent, targetItem ) ) {
 //      children = targetItem.getChildren();
 //      index = 0;
 //    }
 //    else if( targetItemParent != null) {
 //      children = targetItemParent.getChildren();
 //      index = children.indexOf( targetItem ) + 1;
 //    }
 //    else {
 //      children = sourceItemParent.getChildren();
 //      index = 0;
 //    }
 //
 //    children.add( index, sourceItem );
 //
 //    treeView.getSelectionModel().clearSelection();
 //    treeView.getSelectionModel().select( sourceItem );
 //
 //    // TODO: Notify a listener of the old and new tree item position.
 //
 //    event.setDropCompleted( true );
 //  }
 //
 //  private void dragClear() {
 //    final var targetCell = mTargetCell;
 //
 //    if( targetCell != null ) {
 //      targetCell.getStyleClass().remove( STYLE_CLASS_DROP_TARGET );
 //    }
 //  }
+}

A src/main/java/com/keenwrite/ui/tree/AltTreeView.java

 /* Copyright 2020-2021 White Magic Software, Ltd. -- All rights reserved. */
 package com.keenwrite.ui.tree;
 import javafx.scene.control.TreeItem;
 import javafx.scene.control.TreeView;
 import javafx.util.StringConverter;
 /**
  * Responsible for allowing users to edit items in the tree as well as
  * drag and drop. The goal is to be a drop-in replacement for the regular
  * JavaFX {@link TreeView} that does not offer editing and moving {@link
  * TreeItem} instances.
+ *
  * @param <T> The type of data to edit.
  */
 public class AltTreeView<T> extends TreeView<T> {
   public AltTreeView(
     final TreeItem<T> root, final StringConverter<T> converter ) {
     super( root );
     setEditable( true );
     setCellFactory( new AltTreeCellFactory<>( converter ) );
     setShowRoot( false );
     // When focus is lost, clear the selected item only when not editing.
     focusedProperty().addListener( ( c, o, n ) -> {
       if( o && getEditingItem() == null ) {
         getSelectionModel().clearSelection();
+      }
     } );
+  }
+}

A src/main/java/com/keenwrite/ui/tree/TreeItemConverter.java

 /* Copyright 2020-2021 White Magic Software, Ltd. -- All rights reserved. */
 package com.keenwrite.ui.tree;
 import javafx.util.StringConverter;
 /**
  * Responsible for converting objects to and from string instances. The
  * tree items contain only strings, so this effectively is a string-to-string
  * converter, which allows the implementation to retain its generics.
  */
 public class TreeItemConverter extends StringConverter<String> {
   @Override
   public String toString( final String object ) {
     return sanitize( object );
+  }
   @Override
   public String fromString( final String string ) {
     return sanitize( string );
+  }
   private String sanitize( final String string ) {
     return string == null ? "" : string;
+  }
+}

M src/main/resources/com/keenwrite/messages.properties

 Main.menu.insert=_Insert
 Main.menu.format=Forma_t
 Main.menu.definition=_Definition
 Main.menu.view=_View
 Main.menu.help=_Help
 # ########################################################################
 # Detachable Tabs
 # ########################################################################
 # {0} is the application title; {1} is a unique window ID.
 Detach.tab.title={0} - {1}
 # ########################################################################
 # Status Bar
 # ########################################################################
 Main.status.text.offset=offset
 Main.status.line=Line {0} of {1}, ${Main.status.text.offset} {2}
 Main.status.state.default=OK
 Main.status.export.success=Saved as {0}
 Main.status.error.bootstrap.eval=Note: Bootstrap definition of ''{0}'' not found
 Main.status.error.parse={0} (near ${Main.status.text.offset} {1})
 Main.status.error.def.blank=Move the caret to a word before inserting a definition
 Main.status.error.def.empty=Create a definition before inserting a definition
 Main.status.error.def.missing=No definition value found for ''{0}''
 Main.status.error.r=Error with [{0}...]: {1}
 Main.status.error.file.missing=Not found: {0}
 Main.status.error.messages.recursion=Lookup depth exceeded, check for loops in ''{0}''
 Main.status.error.messages.syntax=Missing ''}'' in ''{0}''
 Main.status.error.undo=Cannot undo; beginning of undo history reached
 Main.status.error.redo=Cannot redo; end of redo history reached
 Main.status.image.request.init=Initializing HTTP request
 Main.status.image.request.fetch=Requesting content type from {0}
 Main.status.image.request.success=Determined content type ''{0}''
 Main.status.image.request.error.media=No media type for ''{0}''
 Main.status.image.request.error.cert=Could not accept certificate for ''{0}''
 Main.status.font.search.missing=No font name starting with ''{0}'' was found
 # ########################################################################
 # Search Bar
 # ########################################################################
 Main.search.stop.tooltip=Close search bar
 Main.search.stop.icon=CLOSE
 Main.search.next.tooltip=Find next match
 Main.search.next.icon=CHEVRON_DOWN
 Main.search.prev.tooltip=Find previous match
 Main.search.prev.icon=CHEVRON_UP
 Main.search.find.tooltip=Search document for text
 Main.search.find.icon=SEARCH
 Main.search.match.none=No matches
 Main.search.match.some={0} of {1} matches
 # ########################################################################
 # Workspace preferences
 # ########################################################################
 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 {0}application.r.working.directory{1} 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 definitions.
 workspace.r.delimiter.began.title=Opening
 workspace.r.delimiter.ended=Delimiter Suffix
 workspace.r.delimiter.ended.desc=Suffix of expression that wraps inserted definitions.
 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.order=Extensions
 workspace.images.order.desc=Preferred order of image file types to embed, separated by spaces.
 workspace.images.order.title=Extensions
 workspace.definition=Definition
 workspace.definition.path=File name
 workspace.definition.path.desc=Absolute path to interpolated string definition.
 workspace.definition.path.title=Path
 workspace.definition.delimiter.began=Delimiter Prefix
 workspace.definition.delimiter.began.desc=Indicates when a definition key is starting.
 workspace.definition.delimiter.began.title=Opening
 workspace.definition.delimiter.ended=Delimiter Suffix
 workspace.definition.delimiter.ended.desc=Indicates when a definition key is ending.
 workspace.definition.delimiter.ended.title=Closing
 workspace.ui.theme=Themes
 workspace.ui.theme.selection=Bundled
 workspace.ui.theme.selection.desc=Pre-packaged application style (default: Modena Light)
 workspace.ui.theme.selection.title=Name
 workspace.ui.theme.custom=Custom
 workspace.ui.theme.custom.desc=User-defined JavaFX cascading stylesheet file
 workspace.ui.theme.custom.title=Path
 workspace.ui.font=Fonts
 workspace.ui.font.editor=Editor Font
 workspace.ui.font.editor.name=Name
 workspace.ui.font.editor.name.desc=Text editor font name (sans-serif font recommended).
 workspace.ui.font.editor.name.title=Family
 workspace.ui.font.editor.size=Size
 workspace.ui.font.editor.size.desc=Font size.
 workspace.ui.font.editor.size.title=Points
 workspace.ui.font.preview=Preview Font
 workspace.ui.font.preview.name=Name
 workspace.ui.font.preview.name.desc=Preview pane font name (must support ligatures, serif font recommended).
 workspace.ui.font.preview.name.title=Family
 workspace.ui.font.preview.size=Size
 workspace.ui.font.preview.size.desc=Font size.
 workspace.ui.font.preview.size.title=Points
 workspace.ui.font.preview.mono.name=Name
 workspace.ui.font.preview.mono.name.desc=Monospace font name.
 workspace.ui.font.preview.mono.name.title=Family
 workspace.ui.font.preview.mono.size=Size
 workspace.ui.font.preview.mono.size.desc=Monospace font size.
 workspace.ui.font.preview.mono.size.title=Points
 workspace.language=Language
 workspace.language.locale=Internationalization
 workspace.language.locale.desc=Language for application and HTML export.
 workspace.language.locale.title=Locale
 # ########################################################################
 # Definition Pane and its Tree View
 # ########################################################################
 Definition.menu.add.default=Undefined
 # ########################################################################
 # Definition Pane
 # ########################################################################
 Pane.definition.node.root.title=Definitions
 # ########################################################################
 # Failure messages with respect to YAML files.
 # ########################################################################
 yaml.error.open=Could not open YAML file (ensure non-empty file).
 yaml.error.unresolvable=Too much indirection for: ''{0}'' = ''{1}''.
 yaml.error.missing=Empty definition value for key ''{0}''.
 yaml.error.tree.form=Unassigned definition near ''{0}''.
 # ########################################################################
 # Text Resource
 # ########################################################################
 TextResource.load.error.unsaved=The file ''{0}'' is unsaved or does not exist.
 TextResource.load.error.permissions=The file ''{0}'' must be readable and writable.
 # ########################################################################
 # Text Resources
 # ########################################################################
 TextResource.saveFailed.message=Failed to save ''{0}''.\n\nReason: {1}
 TextResource.saveFailed.title=Save
 # ########################################################################
 # File Open
 # ########################################################################
 Dialog.file.choose.open.title=Open File
 Dialog.file.choose.save.title=Save File
 Dialog.file.choose.export.title=Export File
 Dialog.file.choose.filter.title.source=Source Files
 Dialog.file.choose.filter.title.definition=Definition Files
 Dialog.file.choose.filter.title.xml=XML Files
 Dialog.file.choose.filter.title.all=All Files
 # ########################################################################
 # Browse File
 # ########################################################################
 BrowseFileButton.chooser.title=Browse for local file
 BrowseFileButton.chooser.allFilesFilter=All Files
 BrowseFileButton.tooltip=${BrowseFileButton.chooser.title}
 # ########################################################################
 # Alert Dialog
 # ########################################################################
 Alert.file.close.title=Close
 Alert.file.close.text=Save changes to {0}?
 # ########################################################################
 # Image Dialog
 # ########################################################################
 Dialog.image.title=Image
 Dialog.image.chooser.imagesFilter=Images
 Dialog.image.previewLabel.text=Markdown Preview\:
 Dialog.image.textLabel.text=Alternate Text\:
 Dialog.image.titleLabel.text=Title (tooltip)\:
 Dialog.image.urlLabel.text=Image URL\:
 # ########################################################################
 # Hyperlink Dialog
 # ########################################################################
 Dialog.link.title=Link
 Dialog.link.previewLabel.text=Markdown Preview\:
 Dialog.link.textLabel.text=Link Text\:
 Dialog.link.titleLabel.text=Title (tooltip)\:
 Dialog.link.urlLabel.text=Link URL\:
 # ########################################################################
 # About Dialog
 # ########################################################################
 Dialog.about.title=About {0}
 Dialog.about.header={0}
 Dialog.about.content=Copyright 2016-{0} White Magic Software, Ltd.\n\nVersion: {1}
 # ########################################################################
 # Application Actions
 # ########################################################################
 App.action.file.new.description=Create a new file
 App.action.file.new.accelerator=Shortcut+N
 App.action.file.new.icon=FILE_ALT
 App.action.file.new.text=_New
 App.action.file.open.description=Open a new file
 App.action.file.open.accelerator=Shortcut+O
 App.action.file.open.text=_Open...
 App.action.file.open.icon=FOLDER_OPEN_ALT
 App.action.file.close.description=Close the current document
 App.action.file.close.accelerator=Shortcut+W
 App.action.file.close.text=_Close
 App.action.file.close_all.description=Close all open documents
 App.action.file.close_all.accelerator=Ctrl+F4
 App.action.file.close_all.text=Close All
 App.action.file.save.description=Save the document
 App.action.file.save.accelerator=Shortcut+S
 App.action.file.save.text=_Save
 App.action.file.save.icon=FLOPPY_ALT
 App.action.file.save_as.description=Rename the current document
 App.action.file.save_as.text=Save _As
 App.action.file.save_all.description=Save all open documents
 App.action.file.save_all.accelerator=Shortcut+Shift+S
 App.action.file.save_all.text=Save A_ll
 App.action.file.export.html_svg.description=Export the current document as HTML + SVG
 App.action.file.export.text=_Export As
 App.action.file.export.html_svg.text=HTML and S_VG
 App.action.file.export.html_tex.description=Export the current document as HTML + TeX
 App.action.file.export.html_tex.text=HTML and _TeX
 App.action.file.export.markdown.description=Export the current document as Markdown
 App.action.file.export.markdown.text=Markdown
 App.action.file.exit.description=Quit the application
 App.action.file.exit.text=E_xit
 App.action.edit.undo.description=Undo the previous edit
 App.action.edit.undo.accelerator=Shortcut+Z
 App.action.edit.undo.text=_Undo
 App.action.edit.undo.icon=UNDO
 App.action.edit.redo.description=Redo the previous edit
 App.action.edit.redo.accelerator=Shortcut+Y
 App.action.edit.redo.text=_Redo
 App.action.edit.redo.icon=REPEAT
 App.action.edit.cut.description=Delete the selected text or line
 App.action.edit.cut.accelerator=Shortcut+X
 App.action.edit.cut.text=Cu_t
 App.action.edit.cut.icon=CUT
 App.action.edit.copy.description=Copy the selected text
 App.action.edit.copy.accelerator=Shortcut+C
 App.action.edit.copy.text=_Copy
 App.action.edit.copy.icon=COPY
 App.action.edit.paste.description=Paste from the clipboard
 App.action.edit.paste.accelerator=Shortcut+V
 App.action.edit.paste.text=_Paste
 App.action.edit.paste.icon=PASTE
 App.action.edit.select_all.description=Highlight the current document text
 App.action.edit.select_all.accelerator=Shortcut+A
 App.action.edit.select_all.text=Select _All
 App.action.edit.find.description=Search for text in the document
 App.action.edit.find.accelerator=Shortcut+F
 App.action.edit.find.text=_Find
 App.action.edit.find.icon=SEARCH
 App.action.edit.find_next.description=Find next occurrence
 App.action.edit.find_next.accelerator=F3
 App.action.edit.find_next.text=Find _Next
 App.action.edit.find_prev.description=Find previous occurrence
 App.action.edit.find_prev.accelerator=Shift+F3
 App.action.edit.find_prev.text=Find _Prev
 App.action.edit.preferences.description=Edit user preferences
 App.action.edit.preferences.accelerator=Ctrl+Alt+S
 App.action.edit.preferences.text=_Preferences
 App.action.format.bold.description=Insert strong text
 App.action.format.bold.accelerator=Shortcut+B
 App.action.format.bold.text=_Bold
 App.action.format.bold.icon=BOLD
 App.action.format.italic.description=Insert text emphasis
 App.action.format.italic.accelerator=Shortcut+I
 App.action.format.italic.text=_Italic
 App.action.format.italic.icon=ITALIC
 App.action.format.superscript.description=Insert superscript text
 App.action.format.superscript.accelerator=Shortcut+[
 App.action.format.superscript.text=Su_perscript
 App.action.format.superscript.icon=SUPERSCRIPT
 App.action.format.subscript.description=Insert subscript text
 App.action.format.subscript.accelerator=Shortcut+]
 App.action.format.subscript.text=Su_bscript
 App.action.format.subscript.icon=SUBSCRIPT
 App.action.format.strikethrough.description=Insert struck text
 App.action.format.strikethrough.accelerator=Shortcut+T
 App.action.format.strikethrough.text=Stri_kethrough
 App.action.format.strikethrough.icon=STRIKETHROUGH
 App.action.insert.blockquote.description=Insert blockquote
 App.action.insert.blockquote.accelerator=Ctrl+Q
 App.action.insert.blockquote.text=_Blockquote
 App.action.insert.blockquote.icon=QUOTE_LEFT
 App.action.insert.code.description=Insert inline code
 App.action.insert.code.accelerator=Shortcut+K
 App.action.insert.code.text=Inline _Code
 App.action.insert.code.icon=CODE
 App.action.insert.fenced_code_block.description=Insert code block
 App.action.insert.fenced_code_block.accelerator=Shortcut+Shift+K
 App.action.insert.fenced_code_block.text=_Fenced Code Block
 App.action.insert.fenced_code_block.prompt.text=Enter code here
 App.action.insert.fenced_code_block.icon=FILE_CODE_ALT
 App.action.insert.link.description=Insert hyperlink
 App.action.insert.link.accelerator=Shortcut+L
 App.action.insert.link.text=_Link...
 App.action.insert.link.icon=LINK
 App.action.insert.image.description=Insert image
 App.action.insert.image.accelerator=Shortcut+G
 App.action.insert.image.text=_Image...
 App.action.insert.image.icon=PICTURE_ALT
 App.action.insert.heading.description=Insert heading level
 App.action.insert.heading.accelerator=Shortcut+
 App.action.insert.heading.icon=HEADER
 App.action.insert.heading_1.description=${App.action.insert.heading.description} 1
 App.action.insert.heading_1.accelerator=${App.action.insert.heading.accelerator}1
 App.action.insert.heading_1.text=Heading _1
 App.action.insert.heading_1.icon=${App.action.insert.heading.icon}
 App.action.insert.heading_2.description=${App.action.insert.heading.description} 2
 App.action.insert.heading_2.accelerator=${App.action.insert.heading.accelerator}2
 App.action.insert.heading_2.text=Heading _2
 App.action.insert.heading_2.icon=${App.action.insert.heading.icon}
 App.action.insert.heading_3.description=${App.action.insert.heading.description} 3
 App.action.insert.heading_3.accelerator=${App.action.insert.heading.accelerator}3
 App.action.insert.heading_3.text=Heading _3
 App.action.insert.heading_3.icon=${App.action.insert.heading.icon}
 App.action.insert.unordered_list.description=Insert bulleted list
 App.action.insert.unordered_list.accelerator=Shortcut+U
 App.action.insert.unordered_list.text=_Unordered List
 App.action.insert.unordered_list.icon=LIST_UL
 App.action.insert.ordered_list.description=Insert enumerated list
 App.action.insert.ordered_list.accelerator=Shortcut+Shift+O
 App.action.insert.ordered_list.text=_Ordered List
 App.action.insert.ordered_list.icon=LIST_OL
 App.action.insert.horizontal_rule.description=Insert horizontal rule
 App.action.insert.horizontal_rule.accelerator=Shortcut+H
 App.action.insert.horizontal_rule.text=_Horizontal Rule
 App.action.insert.horizontal_rule.icon=LIST_OL
 App.action.definition.create.description=Create a new variable definition
 App.action.definition.create.text=_Create
 App.action.definition.create.icon=TREE
 App.action.definition.create.tooltip=Add new item (Insert)
 App.action.definition.rename.description=Rename the selected variable definition
 App.action.definition.rename.text=_Rename
 App.action.definition.rename.icon=EDIT
 App.action.definition.rename.tooltip=Rename selected item (F2)
 App.action.definition.delete.description=Delete the selected variable definitions
 App.action.definition.delete.text=De_lete
 App.action.definition.delete.icon=TRASH
 App.action.definition.delete.tooltip=Delete selected items (Delete)
 App.action.definition.insert.description=Insert a definition
 Main.menu.definition=_Variable
 Main.menu.view=Vie_w
 Main.menu.help=_Help
 # ########################################################################
 # Detachable Tabs
 # ########################################################################
 # {0} is the application title; {1} is a unique window ID.
 Detach.tab.title={0} - {1}
 # ########################################################################
 # Status Bar
 # ########################################################################
 Main.status.text.offset=offset
 Main.status.line=Line {0} of {1}, ${Main.status.text.offset} {2}
 Main.status.state.default=OK
 Main.status.export.success=Saved as {0}
 Main.status.error.bootstrap.eval=Note: Bootstrap variable of ''{0}'' not found
 Main.status.error.parse={0} (near ${Main.status.text.offset} {1})
 Main.status.error.def.blank=Move the caret to a word before inserting a variable
 Main.status.error.def.empty=Create a variable before inserting one
 Main.status.error.def.missing=No variable value found for ''{0}''
 Main.status.error.r=Error with [{0}...]: {1}
 Main.status.error.file.missing=Not found: {0}
 Main.status.error.messages.recursion=Lookup depth exceeded, check for loops in ''{0}''
 Main.status.error.messages.syntax=Missing ''}'' in ''{0}''
 Main.status.error.undo=Cannot undo; beginning of undo history reached
 Main.status.error.redo=Cannot redo; end of redo history reached
 Main.status.image.request.init=Initializing HTTP request
 Main.status.image.request.fetch=Requesting content type from {0}
 Main.status.image.request.success=Determined content type ''{0}''
 Main.status.image.request.error.media=No media type for ''{0}''
 Main.status.image.request.error.cert=Could not accept certificate for ''{0}''
 Main.status.font.search.missing=No font name starting with ''{0}'' was found
 # ########################################################################
 # Search Bar
 # ########################################################################
 Main.search.stop.tooltip=Close search bar
 Main.search.stop.icon=CLOSE
 Main.search.next.tooltip=Find next match
 Main.search.next.icon=CHEVRON_DOWN
 Main.search.prev.tooltip=Find previous match
 Main.search.prev.icon=CHEVRON_UP
 Main.search.find.tooltip=Search document for text
 Main.search.find.icon=SEARCH
 Main.search.match.none=No matches
 Main.search.match.some={0} of {1} matches
 # ########################################################################
 # Workspace preferences
 # ########################################################################
 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 {0}application.r.working.directory{1} 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.order=Extensions
 workspace.images.order.desc=Preferred order of image file types to embed, separated by spaces.
 workspace.images.order.title=Extensions
 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.theme=Themes
 workspace.ui.theme.selection=Bundled
 workspace.ui.theme.selection.desc=Pre-packaged application style (default: Modena Light)
 workspace.ui.theme.selection.title=Name
 workspace.ui.theme.custom=Custom
 workspace.ui.theme.custom.desc=User-defined JavaFX cascading stylesheet file
 workspace.ui.theme.custom.title=Path
 workspace.ui.font=Fonts
 workspace.ui.font.editor=Editor Font
 workspace.ui.font.editor.name=Name
 workspace.ui.font.editor.name.desc=Text editor font name (sans-serif font recommended).
 workspace.ui.font.editor.name.title=Family
 workspace.ui.font.editor.size=Size
 workspace.ui.font.editor.size.desc=Font size.
 workspace.ui.font.editor.size.title=Points
 workspace.ui.font.preview=Preview Font
 workspace.ui.font.preview.name=Name
 workspace.ui.font.preview.name.desc=Preview pane font name (must support ligatures, serif font recommended).
 workspace.ui.font.preview.name.title=Family
 workspace.ui.font.preview.size=Size
 workspace.ui.font.preview.size.desc=Font size.
 workspace.ui.font.preview.size.title=Points
 workspace.ui.font.preview.mono.name=Name
 workspace.ui.font.preview.mono.name.desc=Monospace font name.
 workspace.ui.font.preview.mono.name.title=Family
 workspace.ui.font.preview.mono.size=Size
 workspace.ui.font.preview.mono.size.desc=Monospace font size.
 workspace.ui.font.preview.mono.size.title=Points
 workspace.language=Language
 workspace.language.locale=Internationalization
 workspace.language.locale.desc=Language for application and HTML export.
 workspace.language.locale.title=Locale
 # ########################################################################
 # Definition Pane and its Tree View
 # ########################################################################
 Definition.menu.add.default=Undefined
 # ########################################################################
 # Variable Definitions Pane
 # ########################################################################
 Pane.definition.node.root.title=Variables
 # ########################################################################
 # HTML Preview Pane
 # ########################################################################
 Pane.preview.title=Preview
 # ########################################################################
 # Document Outline Pane
 # ########################################################################
 Pane.outline.title=Outline
 # ########################################################################
 # Failure messages with respect to YAML files.
 # ########################################################################
 yaml.error.open=Could not open YAML file (ensure non-empty file).
 yaml.error.unresolvable=Too much indirection for: ''{0}'' = ''{1}''.
 yaml.error.missing=Empty variable value for key ''{0}''.
 yaml.error.tree.form=Unassigned variable near ''{0}''.
 # ########################################################################
 # Text Resource
 # ########################################################################
 TextResource.load.error.unsaved=The file ''{0}'' is unsaved or does not exist.
 TextResource.load.error.permissions=The file ''{0}'' must be readable and writable.
 # ########################################################################
 # Text Resources
 # ########################################################################
 TextResource.saveFailed.message=Failed to save ''{0}''.\n\nReason: {1}
 TextResource.saveFailed.title=Save
 # ########################################################################
 # File Open
 # ########################################################################
 Dialog.file.choose.open.title=Open File
 Dialog.file.choose.save.title=Save File
 Dialog.file.choose.export.title=Export File
 Dialog.file.choose.filter.title.source=Source Files
 Dialog.file.choose.filter.title.definition=Variable Files
 Dialog.file.choose.filter.title.xml=XML Files
 Dialog.file.choose.filter.title.all=All Files
 # ########################################################################
 # Browse File
 # ########################################################################
 BrowseFileButton.chooser.title=Browse for local file
 BrowseFileButton.chooser.allFilesFilter=All Files
 BrowseFileButton.tooltip=${BrowseFileButton.chooser.title}
 # ########################################################################
 # Alert Dialog
 # ########################################################################
 Alert.file.close.title=Close
 Alert.file.close.text=Save changes to {0}?
 # ########################################################################
 # Image Dialog
 # ########################################################################
 Dialog.image.title=Image
 Dialog.image.chooser.imagesFilter=Images
 Dialog.image.previewLabel.text=Markdown Preview\:
 Dialog.image.textLabel.text=Alternate Text\:
 Dialog.image.titleLabel.text=Title (tooltip)\:
 Dialog.image.urlLabel.text=Image URL\:
 # ########################################################################
 # Hyperlink Dialog
 # ########################################################################
 Dialog.link.title=Link
 Dialog.link.previewLabel.text=Markdown Preview\:
 Dialog.link.textLabel.text=Link Text\:
 Dialog.link.titleLabel.text=Title (tooltip)\:
 Dialog.link.urlLabel.text=Link URL\:
 # ########################################################################
 # About Dialog
 # ########################################################################
 Dialog.about.title=About {0}
 Dialog.about.header={0}
 Dialog.about.content=Copyright 2016-{0} White Magic Software, Ltd.\n\nVersion: {1}
 # ########################################################################
 # Application Actions
 # ########################################################################
 App.action.file.new.description=Create a new file
 App.action.file.new.accelerator=Shortcut+N
 App.action.file.new.icon=FILE_ALT
 App.action.file.new.text=_New
 App.action.file.open.description=Open a new file
 App.action.file.open.accelerator=Shortcut+O
 App.action.file.open.text=_Open...
 App.action.file.open.icon=FOLDER_OPEN_ALT
 App.action.file.close.description=Close the current document
 App.action.file.close.accelerator=Shortcut+W
 App.action.file.close.text=_Close
 App.action.file.close_all.description=Close all open documents
 App.action.file.close_all.accelerator=Ctrl+F4
 App.action.file.close_all.text=Close All
 App.action.file.save.description=Save the document
 App.action.file.save.accelerator=Shortcut+S
 App.action.file.save.text=_Save
 App.action.file.save.icon=FLOPPY_ALT
 App.action.file.save_as.description=Rename the current document
 App.action.file.save_as.text=Save _As
 App.action.file.save_all.description=Save all open documents
 App.action.file.save_all.accelerator=Shortcut+Shift+S
 App.action.file.save_all.text=Save A_ll
 App.action.file.export.html_svg.description=Export the current document as HTML + SVG
 App.action.file.export.text=_Export As
 App.action.file.export.html_svg.text=HTML and S_VG
 App.action.file.export.html_tex.description=Export the current document as HTML + TeX
 App.action.file.export.html_tex.text=HTML and _TeX
 App.action.file.export.markdown.description=Export the current document as Markdown
 App.action.file.export.markdown.text=Markdown
 App.action.file.exit.description=Quit the application
 App.action.file.exit.text=E_xit
 App.action.edit.undo.description=Undo the previous edit
 App.action.edit.undo.accelerator=Shortcut+Z
 App.action.edit.undo.text=_Undo
 App.action.edit.undo.icon=UNDO
 App.action.edit.redo.description=Redo the previous edit
 App.action.edit.redo.accelerator=Shortcut+Y
 App.action.edit.redo.text=_Redo
 App.action.edit.redo.icon=REPEAT
 App.action.edit.cut.description=Delete the selected text or line
 App.action.edit.cut.accelerator=Shortcut+X
 App.action.edit.cut.text=Cu_t
 App.action.edit.cut.icon=CUT
 App.action.edit.copy.description=Copy the selected text
 App.action.edit.copy.accelerator=Shortcut+C
 App.action.edit.copy.text=_Copy
 App.action.edit.copy.icon=COPY
 App.action.edit.paste.description=Paste from the clipboard
 App.action.edit.paste.accelerator=Shortcut+V
 App.action.edit.paste.text=_Paste
 App.action.edit.paste.icon=PASTE
 App.action.edit.select_all.description=Highlight the current document text
 App.action.edit.select_all.accelerator=Shortcut+A
 App.action.edit.select_all.text=Select _All
 App.action.edit.find.description=Search for text in the document
 App.action.edit.find.accelerator=Shortcut+F
 App.action.edit.find.text=_Find
 App.action.edit.find.icon=SEARCH
 App.action.edit.find_next.description=Find next occurrence
 App.action.edit.find_next.accelerator=F3
 App.action.edit.find_next.text=Find _Next
 App.action.edit.find_prev.description=Find previous occurrence
 App.action.edit.find_prev.accelerator=Shift+F3
 App.action.edit.find_prev.text=Find _Prev
 App.action.edit.preferences.description=Edit user preferences
 App.action.edit.preferences.accelerator=Ctrl+Alt+S
 App.action.edit.preferences.text=_Preferences
 App.action.format.bold.description=Insert strong text
 App.action.format.bold.accelerator=Shortcut+B
 App.action.format.bold.text=_Bold
 App.action.format.bold.icon=BOLD
 App.action.format.italic.description=Insert text emphasis
 App.action.format.italic.accelerator=Shortcut+I
 App.action.format.italic.text=_Italic
 App.action.format.italic.icon=ITALIC
 App.action.format.superscript.description=Insert superscript text
 App.action.format.superscript.accelerator=Shortcut+[
 App.action.format.superscript.text=Su_perscript
 App.action.format.superscript.icon=SUPERSCRIPT
 App.action.format.subscript.description=Insert subscript text
 App.action.format.subscript.accelerator=Shortcut+]
 App.action.format.subscript.text=Su_bscript
 App.action.format.subscript.icon=SUBSCRIPT
 App.action.format.strikethrough.description=Insert struck text
 App.action.format.strikethrough.accelerator=Shortcut+T
 App.action.format.strikethrough.text=Stri_kethrough
 App.action.format.strikethrough.icon=STRIKETHROUGH
 App.action.insert.blockquote.description=Insert blockquote
 App.action.insert.blockquote.accelerator=Ctrl+Q
 App.action.insert.blockquote.text=_Blockquote
 App.action.insert.blockquote.icon=QUOTE_LEFT
 App.action.insert.code.description=Insert inline code
 App.action.insert.code.accelerator=Shortcut+K
 App.action.insert.code.text=Inline _Code
 App.action.insert.code.icon=CODE
 App.action.insert.fenced_code_block.description=Insert code block
 App.action.insert.fenced_code_block.accelerator=Shortcut+Shift+K
 App.action.insert.fenced_code_block.text=_Fenced Code Block
 App.action.insert.fenced_code_block.prompt.text=Enter code here
 App.action.insert.fenced_code_block.icon=FILE_CODE_ALT
 App.action.insert.link.description=Insert hyperlink
 App.action.insert.link.accelerator=Shortcut+L
 App.action.insert.link.text=_Link...
 App.action.insert.link.icon=LINK
 App.action.insert.image.description=Insert image
 App.action.insert.image.accelerator=Shortcut+G
 App.action.insert.image.text=_Image...
 App.action.insert.image.icon=PICTURE_ALT
 App.action.insert.heading.description=Insert heading level
 App.action.insert.heading.accelerator=Shortcut+
 App.action.insert.heading.icon=HEADER
 App.action.insert.heading_1.description=${App.action.insert.heading.description} 1
 App.action.insert.heading_1.accelerator=${App.action.insert.heading.accelerator}1
 App.action.insert.heading_1.text=Heading _1
 App.action.insert.heading_1.icon=${App.action.insert.heading.icon}
 App.action.insert.heading_2.description=${App.action.insert.heading.description} 2
 App.action.insert.heading_2.accelerator=${App.action.insert.heading.accelerator}2
 App.action.insert.heading_2.text=Heading _2
 App.action.insert.heading_2.icon=${App.action.insert.heading.icon}
 App.action.insert.heading_3.description=${App.action.insert.heading.description} 3
 App.action.insert.heading_3.accelerator=${App.action.insert.heading.accelerator}3
 App.action.insert.heading_3.text=Heading _3
 App.action.insert.heading_3.icon=${App.action.insert.heading.icon}
 App.action.insert.unordered_list.description=Insert bulleted list
 App.action.insert.unordered_list.accelerator=Shortcut+U
 App.action.insert.unordered_list.text=_Unordered List
 App.action.insert.unordered_list.icon=LIST_UL
 App.action.insert.ordered_list.description=Insert enumerated list
 App.action.insert.ordered_list.accelerator=Shortcut+Shift+O
 App.action.insert.ordered_list.text=_Ordered List
 App.action.insert.ordered_list.icon=LIST_OL
 App.action.insert.horizontal_rule.description=Insert horizontal rule
 App.action.insert.horizontal_rule.accelerator=Shortcut+H
 App.action.insert.horizontal_rule.text=_Horizontal Rule
 App.action.insert.horizontal_rule.icon=LIST_OL
 App.action.definition.create.description=Create a new variable
 App.action.definition.create.text=_Create
 App.action.definition.create.icon=TREE
 App.action.definition.create.tooltip=Add new item (Insert)
 App.action.definition.rename.description=Rename the selected variable
 App.action.definition.rename.text=_Rename
 App.action.definition.rename.icon=EDIT
 App.action.definition.rename.tooltip=Rename selected item (F2)
 App.action.definition.delete.description=Delete the selected variables
 App.action.definition.delete.text=De_lete
 App.action.definition.delete.icon=TRASH
 App.action.definition.delete.tooltip=Delete selected items (Delete)
 App.action.definition.insert.description=Insert a variable
 App.action.definition.insert.accelerator=Ctrl+Space
 App.action.definition.insert.text=_Insert