Dave Jarvis' Repositories

Home Files Commits Tags Clone

Repository:

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

M _config.yaml

 ---
 River: "Door"
 Ocean: "Floor"
 application:
   title: "Scrivenvar"

M build.gradle

   id 'application'
   id 'org.openjfx.javafxplugin' version '0.0.8'
   id 'com.palantir.git-version' version '0.12.3'
+}
 sourceCompatibility = JavaVersion.VERSION_11
 version = '1.5.0'
 applicationName = 'scrivenvar'
 mainClassName = 'com.scrivenvar.Main'
 def launcherClassName = 'com.scrivenvar.Launcher'
 version gitVersion()
 mainClassName = "com.${applicationName}.Main"
 def launcherClassName = "com.${applicationName}.Launcher"
 def propertiesFile = new File("src/main/resources/com/$applicationName/app.properties")
 propertiesFile.write("application.version=${version}")
 jar {
+  }
   archiveFileName = 'scrivenvar.jar'
   archiveFileName = "${applicationName}.jar"
   exclude 'META-INF/*.RSA', 'META-INF/*.SF', 'META-INF/*.DSA'

M images/screenshot.png

Binary file

M src/main/java/com/scrivenvar/Constants.java

   // Bootstrapping...
   public static final String SETTINGS_NAME = "/com/scrivenvar/settings" +
       ".properties";
   public static final String SETTINGS_NAME =
       "/com/scrivenvar/settings.properties";
   public static final String APP_TITLE = get( "application.title" );
   public static final String APP_BUNDLE_NAME = get( "application.messages" );
   // Prevent double events when updating files on Linux (save and timestamp).
   public static final int APP_WATCHDOG_TIMEOUT = get(
       "application.watchdog.timeout",
 );
       "application.watchdog.timeout", 100 );
   public static final String STYLESHEET_SCENE = get( "file.stylesheet.scene" );
   public static final String STYLESHEET_MARKDOWN = get(
       "file.stylesheet.markdown" );
   public static final String STYLESHEET_PREVIEW = get( "file.stylesheet" +
                                                            ".preview" );
   public static final String STYLESHEET_PREVIEW = get(
       "file.stylesheet.preview" );
   public static final String FILE_LOGO_16 = get( "file.logo.16" );

M src/main/java/com/scrivenvar/FileEditorTab.java

 import javafx.beans.value.ChangeListener;
 import javafx.beans.value.ObservableValue;
 import javafx.scene.Node;
 import javafx.scene.Scene;
 import javafx.scene.control.Tab;
 import javafx.scene.control.Tooltip;
 import javafx.scene.text.Text;
 import javafx.stage.Window;
 import org.fxmisc.richtext.StyleClassedTextArea;
 import org.fxmisc.richtext.model.TwoDimensional.Position;
 import org.fxmisc.undo.UndoManager;
 import org.mozilla.universalchardet.UniversalDetector;
 import java.io.File;
 import java.io.IOException;
 import java.nio.charset.Charset;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import static com.scrivenvar.Messages.get;
 import static java.nio.charset.StandardCharsets.UTF_8;
 import static java.util.Locale.ENGLISH;
 import static org.fxmisc.richtext.model.TwoDimensional.Bias.Forward;
 /**
  * Editor for a single file.
+ *
  * @author Karl Tauber and White Magic Software, Ltd.
  */
 public final class FileEditorTab extends Tab {
   private final Notifier mNotifier = Services.load( Notifier.class );
   private final EditorPane mEditorPane = new MarkdownEditorPane();
   private final ReadOnlyBooleanWrapper mModified = new ReadOnlyBooleanWrapper();
   private final BooleanProperty canUndo = new SimpleBooleanProperty();
   private final BooleanProperty canRedo = new SimpleBooleanProperty();
   /**
    * Character encoding used by the file (or default encoding if none found).
    */
   private Charset mEncoding = UTF_8;
   /**
    * File to load into the editor.
    */
   private Path mPath;
   public FileEditorTab( final Path path ) {
     setPath( path );
     mModified.addListener( ( observable, oldPath, newPath ) -> updateTab() );
     setOnSelectionChanged( e -> {
       if( isSelected() ) {
         Platform.runLater( this::activated );
+      }
     } );
+  }
   private void updateTab() {
     setText( getTabTitle() );
     setGraphic( getModifiedMark() );
     setTooltip( getTabTooltip() );
+  }
   /**
    * Returns the base filename (without the directory names).
+   *
    * @return The untitled text if the path hasn't been set.
    */
   private String getTabTitle() {
     return getPath().getFileName().toString();
+  }
   /**
    * Returns the full filename represented by the path.
+   *
    * @return The untitled text if the path hasn't been set.
    */
   private Tooltip getTabTooltip() {
     final Path filePath = getPath();
     return new Tooltip( filePath == null ? "" : filePath.toString() );
+  }
   /**
    * Returns a marker to indicate whether the file has been modified.
+   *
    * @return "*" when the file has changed; otherwise null.
    */
   private Text getModifiedMark() {
     return isModified() ? new Text( "*" ) : null;
+  }
   /**
    * Called when the user switches tab.
    */
   private void activated() {
     // Tab is closed or no longer active.
     if( getTabPane() == null || !isSelected() ) {
       return;
+    }
     // Switch to the tab without loading if the contents are already in memory.
     if( getContent() != null ) {
       getEditorPane().requestFocus();
       return;
+    }
     // Load the text and update the preview before the undo manager.
     load();
     // Track undo requests -- can only be called *after* load.
     initUndoManager();
     initLayout();
     initFocus();
+  }
   private void initLayout() {
     setContent( getScrollPane() );
+  }
   private Node getScrollPane() {
     return getEditorPane().getScrollPane();
+  }
   private void initFocus() {
     getEditorPane().requestFocus();
+  }
   private void initUndoManager() {
     final UndoManager<?> undoManager = getUndoManager();
     undoManager.forgetHistory();
     // Bind the editor undo manager to the properties.
     mModified.bind( Bindings.not( undoManager.atMarkedPositionProperty() ) );
     canUndo.bind( undoManager.undoAvailableProperty() );
     canRedo.bind( undoManager.redoAvailableProperty() );
+  }
   /**
    * Searches from the caret position forward for the given string.
+   *
    * @param needle The text string to match.
    */
   public void searchNext( final String needle ) {
     final String haystack = getEditorText();
     int index = haystack.indexOf( needle, getCaretPosition() );
     // Wrap around.
     if( index == -1 ) {
       index = haystack.indexOf( needle );
+    }
     if( index >= 0 ) {
       setCaretPosition( index );
       getEditor().selectRange( index, index + needle.length() );
+    }
+  }
   /**
    * Returns the index into the text where the caret blinks happily away.
+   *
    * @return A number from 0 to the editor's document text length.
    */
   public int getCaretPosition() {
     return getEditor().getCaretPosition();
+  }
   /**
    * Moves the caret to a given offset.
+   *
    * @param offset The new caret offset.
    */
   private void setCaretPosition( final int offset ) {
     getEditor().moveTo( offset );
     getEditor().requestFollowCaret();
+  }
   /**
    * Returns the caret's current row and column position.
+   *
    * @return The caret's offset into the document.
    */
   public Position getCaretOffset() {
     return getEditor().offsetToPosition( getCaretPosition(), Forward );
+  }
   /**
    * Allows observers to synchronize caret position changes.
+   *
    * @return An observable caret property value.
    */
   public final ObservableValue<Integer> caretPositionProperty() {
     return getEditor().caretPositionProperty();
+  }
   /**
    * Returns the text area associated with this tab.
+   *
    * @return A text editor.
    */
   private StyleClassedTextArea getEditor() {
     return getEditorPane().getEditor();
+  }
   /**
    * Returns true if the given path exactly matches this tab's path.
+   *
    * @param check The path to compare against.
    * @return true The paths are the same.
    */
   public boolean isPath( final Path check ) {
     final Path filePath = getPath();
     return filePath != null && filePath.equals( check );
+  }
   /**
    * Reads the entire file contents from the path associated with this tab.
    */
   private void load() {
     final Path path = getPath();
     final File file = path.toFile();
     try {
       if( file.exists() ) {
         if( file.canWrite() && file.canRead() ) {
           final EditorPane pane = getEditorPane();
           pane.setText( asString( Files.readAllBytes( path ) ) );
           pane.scrollToTop();
+        }
         else {
           final String msg = get(
               "FileEditor.loadFailed.message",
               file.toString(),
               get( "FileEditor.loadFailed.reason.permissions" )
           );
           getNotifier().notify( msg );
+        }
+      }
     } catch( final Exception ex ) {
       getNotifier().notify( ex );
+    }
+  }
   /**
    * Saves the entire file contents from the path associated with this tab.
+   *
    * @return true The file has been saved.
    */
   public boolean save() {
     try {
       final EditorPane editor = getEditorPane();
       Files.write( getPath(), asBytes( editor.getText() ) );
       editor.getUndoManager().mark();
       return true;
     } catch( final Exception ex ) {
       return alert(
           "FileEditor.saveFailed.title",
           "FileEditor.saveFailed.message",
           ex
       );
+    }
+  }
   /**
    * Creates an alert dialog and waits for it to close.
+   *
    * @param titleKey   Resource bundle key for the alert dialog title.
    * @param messageKey Resource bundle key for the alert dialog message.
    * @param e          The unexpected happening.
    * @return false
    */
   @SuppressWarnings("SameParameterValue")
   private boolean alert(
       final String titleKey, final String messageKey, final Exception e ) {
     final Notifier service = getNotifier();
     final Path filePath = getPath();
     final Notification message = service.createNotification(
         get( titleKey ),
         get( messageKey ),
         filePath == null ? "" : filePath,
         e.getMessage()
     );
     try {
       service.createError( getWindow(), message ).showAndWait();
     } catch( final Exception ex ) {
       getNotifier().notify( ex );
+    }
     return false;
+  }
   private Window getWindow() {
     final Scene scene = getEditorPane().getScene();
     if( scene == null ) {
       throw new UnsupportedOperationException( "No scene window available" );
+    }
     return scene.getWindow();
+  }
   /**
    * Returns a best guess at the file encoding. If the encoding could not be
    * detected, this will return the default charset for the JVM.
+   *
    * @param bytes The bytes to perform character encoding detection.
    * @return The character encoding.
    */
   private Charset detectEncoding( final byte[] bytes ) {
     final UniversalDetector detector = new UniversalDetector( null );
     detector.handleData( bytes, 0, bytes.length );
     detector.dataEnd();
     final String charset = detector.getDetectedCharset();
     final Charset charEncoding = charset == null
         ? Charset.defaultCharset()
         : Charset.forName( charset.toUpperCase( ENGLISH ) );
     detector.reset();
     return charEncoding;
+  }
   /**
    * Converts the given string to an array of bytes using the encoding that was
    * originally detected (if any) and associated with this file.
+   *
    * @param text The text to convert into the original file encoding.
    * @return A series of bytes ready for writing to a file.
    */
   private byte[] asBytes( final String text ) {
     return text.getBytes( getEncoding() );
+  }
   /**
    * Converts the given bytes into a Java String. This will call setEncoding
    * with the encoding detected by the CharsetDetector.
+   *
    * @param text The text of unknown character encoding.
    * @return The text, in its auto-detected encoding, as a String.
    */
   private String asString( final byte[] text ) {
     setEncoding( detectEncoding( text ) );
     return new String( text, getEncoding() );
+  }
   /**
    * Returns the path to the file being edited in this tab.
+   *
    * @return A non-null instance.
    */
   public Path getPath() {
     return mPath;
+  }
   /**
    * Sets the path to a file for editing and then updates the tab with the
    * file contents.
+   *
    * @param path A non-null instance.
    */
   public void setPath( final Path path ) {
     assert path != null;
     mPath = path;
     updateTab();
+  }
   public boolean isModified() {
     return mModified.get();
+  }
   ReadOnlyBooleanProperty modifiedProperty() {
     return mModified.getReadOnlyProperty();
+  }
   BooleanProperty canUndoProperty() {
     return this.canUndo;
+  }
   BooleanProperty canRedoProperty() {
     return this.canRedo;
+  }
   private UndoManager<?> getUndoManager() {
     return getEditorPane().getUndoManager();
+  }
   /**
    * Forwards to the editor pane's listeners for text change events.
+   *
    * @param listener The listener to notify when the text changes.
    */
   public void addTextChangeListener( final ChangeListener<String> listener ) {
     getEditorPane().addTextChangeListener( listener );
+  }
   /**
    * Forwards to the editor pane's listeners for caret paragraph change events.
+   *
    * @param listener The listener to notify when the caret changes paragraphs.
    */
   public void addCaretParagraphListener(
       final ChangeListener<Integer> listener ) {
     getEditorPane().addCaretParagraphListener( listener );
 import javafx.event.Event;
 import javafx.event.EventHandler;
 import javafx.event.EventType;
 import javafx.scene.Node;
 import javafx.scene.Scene;
 import javafx.scene.control.Tab;
 import javafx.scene.control.Tooltip;
 import javafx.scene.text.Text;
 import javafx.stage.Window;
 import org.fxmisc.richtext.StyleClassedTextArea;
 import org.fxmisc.richtext.model.TwoDimensional.Position;
 import org.fxmisc.undo.UndoManager;
 import org.mozilla.universalchardet.UniversalDetector;
 import java.io.File;
 import java.nio.charset.Charset;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import static com.scrivenvar.Messages.get;
 import static java.nio.charset.StandardCharsets.UTF_8;
 import static java.util.Locale.ENGLISH;
 import static org.fxmisc.richtext.model.TwoDimensional.Bias.Forward;
 /**
  * Editor for a single file.
+ *
  * @author Karl Tauber and White Magic Software, Ltd.
  */
 public final class FileEditorTab extends Tab {
   private final Notifier mNotifier = Services.load( Notifier.class );
   private final EditorPane mEditorPane = new MarkdownEditorPane();
   private final ReadOnlyBooleanWrapper mModified = new ReadOnlyBooleanWrapper();
   private final BooleanProperty canUndo = new SimpleBooleanProperty();
   private final BooleanProperty canRedo = new SimpleBooleanProperty();
   /**
    * Character encoding used by the file (or default encoding if none found).
    */
   private Charset mEncoding = UTF_8;
   /**
    * File to load into the editor.
    */
   private Path mPath;
   public FileEditorTab( final Path path ) {
     setPath( path );
     mModified.addListener( ( observable, oldPath, newPath ) -> updateTab() );
     setOnSelectionChanged( e -> {
       if( isSelected() ) {
         Platform.runLater( this::activated );
+      }
     } );
+  }
   private void updateTab() {
     setText( getTabTitle() );
     setGraphic( getModifiedMark() );
     setTooltip( getTabTooltip() );
+  }
   /**
    * Returns the base filename (without the directory names).
+   *
    * @return The untitled text if the path hasn't been set.
    */
   private String getTabTitle() {
     return getPath().getFileName().toString();
+  }
   /**
    * Returns the full filename represented by the path.
+   *
    * @return The untitled text if the path hasn't been set.
    */
   private Tooltip getTabTooltip() {
     final Path filePath = getPath();
     return new Tooltip( filePath == null ? "" : filePath.toString() );
+  }
   /**
    * Returns a marker to indicate whether the file has been modified.
+   *
    * @return "*" when the file has changed; otherwise null.
    */
   private Text getModifiedMark() {
     return isModified() ? new Text( "*" ) : null;
+  }
   /**
    * Called when the user switches tab.
    */
   private void activated() {
     // Tab is closed or no longer active.
     if( getTabPane() == null || !isSelected() ) {
       return;
+    }
     // Switch to the tab without loading if the contents are already in memory.
     if( getContent() != null ) {
       getEditorPane().requestFocus();
       return;
+    }
     // Load the text and update the preview before the undo manager.
     load();
     // Track undo requests -- can only be called *after* load.
     initUndoManager();
     initLayout();
     initFocus();
+  }
   private void initLayout() {
     setContent( getScrollPane() );
+  }
   private Node getScrollPane() {
     return getEditorPane().getScrollPane();
+  }
   private void initFocus() {
     getEditorPane().requestFocus();
+  }
   private void initUndoManager() {
     final UndoManager<?> undoManager = getUndoManager();
     undoManager.forgetHistory();
     // Bind the editor undo manager to the properties.
     mModified.bind( Bindings.not( undoManager.atMarkedPositionProperty() ) );
     canUndo.bind( undoManager.undoAvailableProperty() );
     canRedo.bind( undoManager.redoAvailableProperty() );
+  }
   /**
    * Searches from the caret position forward for the given string.
+   *
    * @param needle The text string to match.
    */
   public void searchNext( final String needle ) {
     final String haystack = getEditorText();
     int index = haystack.indexOf( needle, getCaretPosition() );
     // Wrap around.
     if( index == -1 ) {
       index = haystack.indexOf( needle );
+    }
     if( index >= 0 ) {
       setCaretPosition( index );
       getEditor().selectRange( index, index + needle.length() );
+    }
+  }
   /**
    * Returns the index into the text where the caret blinks happily away.
+   *
    * @return A number from 0 to the editor's document text length.
    */
   public int getCaretPosition() {
     return getEditor().getCaretPosition();
+  }
   /**
    * Moves the caret to a given offset.
+   *
    * @param offset The new caret offset.
    */
   private void setCaretPosition( final int offset ) {
     getEditor().moveTo( offset );
     getEditor().requestFollowCaret();
+  }
   /**
    * Returns the caret's current row and column position.
+   *
    * @return The caret's offset into the document.
    */
   public Position getCaretOffset() {
     return getEditor().offsetToPosition( getCaretPosition(), Forward );
+  }
   /**
    * Allows observers to synchronize caret position changes.
+   *
    * @return An observable caret property value.
    */
   public final ObservableValue<Integer> caretPositionProperty() {
     return getEditor().caretPositionProperty();
+  }
   /**
    * Returns the text area associated with this tab.
+   *
    * @return A text editor.
    */
   private StyleClassedTextArea getEditor() {
     return getEditorPane().getEditor();
+  }
   /**
    * Returns true if the given path exactly matches this tab's path.
+   *
    * @param check The path to compare against.
    * @return true The paths are the same.
    */
   public boolean isPath( final Path check ) {
     final Path filePath = getPath();
     return filePath != null && filePath.equals( check );
+  }
   /**
    * Reads the entire file contents from the path associated with this tab.
    */
   private void load() {
     final Path path = getPath();
     final File file = path.toFile();
     try {
       if( file.exists() ) {
         if( file.canWrite() && file.canRead() ) {
           final EditorPane pane = getEditorPane();
           pane.setText( asString( Files.readAllBytes( path ) ) );
           pane.scrollToTop();
+        }
         else {
           final String msg = get(
               "FileEditor.loadFailed.message",
               file.toString(),
               get( "FileEditor.loadFailed.reason.permissions" )
           );
           getNotifier().notify( msg );
+        }
+      }
     } catch( final Exception ex ) {
       getNotifier().notify( ex );
+    }
+  }
   /**
    * Saves the entire file contents from the path associated with this tab.
+   *
    * @return true The file has been saved.
    */
   public boolean save() {
     try {
       final EditorPane editor = getEditorPane();
       Files.write( getPath(), asBytes( editor.getText() ) );
       editor.getUndoManager().mark();
       return true;
     } catch( final Exception ex ) {
       return alert(
           "FileEditor.saveFailed.title",
           "FileEditor.saveFailed.message",
           ex
       );
+    }
+  }
   /**
    * Creates an alert dialog and waits for it to close.
+   *
    * @param titleKey   Resource bundle key for the alert dialog title.
    * @param messageKey Resource bundle key for the alert dialog message.
    * @param e          The unexpected happening.
    * @return false
    */
   @SuppressWarnings("SameParameterValue")
   private boolean alert(
       final String titleKey, final String messageKey, final Exception e ) {
     final Notifier service = getNotifier();
     final Path filePath = getPath();
     final Notification message = service.createNotification(
         get( titleKey ),
         get( messageKey ),
         filePath == null ? "" : filePath,
         e.getMessage()
     );
     try {
       service.createError( getWindow(), message ).showAndWait();
     } catch( final Exception ex ) {
       getNotifier().notify( ex );
+    }
     return false;
+  }
   private Window getWindow() {
     final Scene scene = getEditorPane().getScene();
     if( scene == null ) {
       throw new UnsupportedOperationException( "No scene window available" );
+    }
     return scene.getWindow();
+  }
   /**
    * Returns a best guess at the file encoding. If the encoding could not be
    * detected, this will return the default charset for the JVM.
+   *
    * @param bytes The bytes to perform character encoding detection.
    * @return The character encoding.
    */
   private Charset detectEncoding( final byte[] bytes ) {
     final UniversalDetector detector = new UniversalDetector( null );
     detector.handleData( bytes, 0, bytes.length );
     detector.dataEnd();
     final String charset = detector.getDetectedCharset();
     final Charset charEncoding = charset == null
         ? Charset.defaultCharset()
         : Charset.forName( charset.toUpperCase( ENGLISH ) );
     detector.reset();
     return charEncoding;
+  }
   /**
    * Converts the given string to an array of bytes using the encoding that was
    * originally detected (if any) and associated with this file.
+   *
    * @param text The text to convert into the original file encoding.
    * @return A series of bytes ready for writing to a file.
    */
   private byte[] asBytes( final String text ) {
     return text.getBytes( getEncoding() );
+  }
   /**
    * Converts the given bytes into a Java String. This will call setEncoding
    * with the encoding detected by the CharsetDetector.
+   *
    * @param text The text of unknown character encoding.
    * @return The text, in its auto-detected encoding, as a String.
    */
   private String asString( final byte[] text ) {
     setEncoding( detectEncoding( text ) );
     return new String( text, getEncoding() );
+  }
   /**
    * Returns the path to the file being edited in this tab.
+   *
    * @return A non-null instance.
    */
   public Path getPath() {
     return mPath;
+  }
   /**
    * Sets the path to a file for editing and then updates the tab with the
    * file contents.
+   *
    * @param path A non-null instance.
    */
   public void setPath( final Path path ) {
     assert path != null;
     mPath = path;
     updateTab();
+  }
   public boolean isModified() {
     return mModified.get();
+  }
   ReadOnlyBooleanProperty modifiedProperty() {
     return mModified.getReadOnlyProperty();
+  }
   BooleanProperty canUndoProperty() {
     return this.canUndo;
+  }
   BooleanProperty canRedoProperty() {
     return this.canRedo;
+  }
   private UndoManager<?> getUndoManager() {
     return getEditorPane().getUndoManager();
+  }
   /**
    * Forwards to the editor pane's listeners for text change events.
+   *
    * @param listener The listener to notify when the text changes.
    */
   public void addTextChangeListener( final ChangeListener<String> listener ) {
     getEditorPane().addTextChangeListener( listener );
+  }
   /**
    * Forwards to the editor pane's listeners for caret paragraph change events.
+   *
    * @param listener The listener to notify when the caret changes paragraphs.
    */
   public void addCaretParagraphListener(
       final ChangeListener<Integer> listener ) {
     getEditorPane().addCaretParagraphListener( listener );
+  }
   public <T extends Event> void addEventFilter(
       final EventType<T> eventType,
       final EventHandler<? super T> eventFilter ) {
     getEditorPane().getEditor().addEventFilter( eventType, eventFilter );
+  }

M src/main/java/com/scrivenvar/FileEditorTabPane.java

 import javafx.stage.FileChooser.ExtensionFilter;
 import javafx.stage.Window;
 import org.fxmisc.richtext.StyledTextArea;
 import java.io.File;
 public final class FileEditorTabPane extends TabPane {
   private final static String FILTER_EXTENSION_TITLES = "Dialog.file.choose" +
       ".filter";
   private final static String FILTER_EXTENSION_TITLES =
       "Dialog.file.choose.filter";
   private final Options mOptions = Services.load( Options.class );
     // a notification is kicked off.
     getSelectionModel().selectedItemProperty().addListener( listener );
+  }
   /**
    * Allows clients to manipulate the editor content directly.
+   *
    * @return The text area for the active file editor.
    */
   public StyledTextArea getEditor() {
     return getActiveFileEditor().getEditorPane().getEditor();
+  }

M src/main/java/com/scrivenvar/Launcher.java

 package com.scrivenvar;
 import java.io.IOException;
 import java.io.InputStream;
 import java.util.Calendar;
 import java.util.Properties;
 import static java.lang.String.format;
 /**
  * Launches the application using the {@link Main} class.
    * @param args Command-line arguments.
    */
   public static void main( final String[] args ) {
   public static void main( final String[] args ) throws IOException {
     showAppInfo();
     Main.main( args );
+  }
   private static void showAppInfo() throws IOException {
     out( format( "%s version %s%n", getTitle(), getVersion() ) );
     out( format( "Copyright %s by White Magic Software, Ltd.%n", getYear() ) );
     out( "Portions copyright 2020 Karl Tauber.\n" );
+  }
   private static void out( final String s ) {
     System.out.print( s );
+  }
   private static String getTitle() throws IOException {
     final Properties properties = loadProperties( "messages.properties" );
     return properties.getProperty( "Main.title" );
+  }
   private static String getVersion() throws IOException {
     final Properties properties = loadProperties( "app.properties" );
     return properties.getProperty( "application.version" );
+  }
   private static String getYear() {
     return Integer.toString( Calendar.getInstance().get( Calendar.YEAR ) );
+  }
   @SuppressWarnings("SameParameterValue")
   private static Properties loadProperties( final String resource )
       throws IOException {
     final Properties properties = new Properties();
     properties.load( getResourceAsStream( getResourceName( resource ) ) );
     return properties;
+  }
   private static String getResourceName( final String resource ) {
     return format( "%s/%s", getPackagePath(), resource );
+  }
   private static String getPackagePath() {
     return Launcher.class.getPackageName().replace( '.', '/' );
+  }
   private static InputStream getResourceAsStream( final String resource ) {
     return Launcher.class.getClassLoader().getResourceAsStream( resource );
+  }
+}

M src/main/java/com/scrivenvar/MainWindow.java

 import static de.jensd.fx.glyphs.fontawesome.FontAwesomeIcon.*;
 import static javafx.event.Event.fireEvent;
 import static javafx.stage.WindowEvent.WINDOW_CLOSE_REQUEST;
 /**
  * Main window containing a tab pane in the center for file editors.
+ *
  * @author Karl Tauber and White Magic Software, Ltd.
  */
 public class MainWindow implements Observer {
   private final Options mOptions = Services.load( Options.class );
   private final Snitch mSnitch = Services.load( Snitch.class );
   private final Settings mSettings = Services.load( Settings.class );
   private final Notifier mNotifier = Services.load( Notifier.class );
   private final Scene mScene;
   private final StatusBar mStatusBar;
   private final Text mLineNumberText;
   private final TextField mFindTextField;
   private DefinitionSource mDefinitionSource = createDefaultDefinitionSource();
   private final DefinitionPane mDefinitionPane = new DefinitionPane();
   private final HTMLPreviewPane mPreviewPane = new HTMLPreviewPane();
   private FileEditorTabPane fileEditorPane;
   /**
    * Prevents re-instantiation of processing classes.
    */
   private final Map<FileEditorTab, Processor<String>> mProcessors =
       new HashMap<>();
   private final Map<String, String> mResolvedMap =
       new HashMap<>( DEFAULT_MAP_SIZE );
   /**
    * Listens on the definition pane for double-click events.
    */
   private VariableNameInjector variableNameInjector;
   /**
    * Called when the definition data is changed.
    */
   final EventHandler<TreeItem.TreeModificationEvent<Event>> mHandler =
       event -> {
         exportDefinitions( getDefinitionPath() );
         interpolateResolvedMap();
         refreshActiveTab();
       };
   public MainWindow() {
     mStatusBar = createStatusBar();
     mLineNumberText = createLineNumberText();
     mFindTextField = createFindTextField();
     mScene = createScene();
     initLayout();
     initFindInput();
     initSnitch();
     initDefinitionListener();
     initTabAddedListener();
     initTabChangedListener();
     initPreferences();
+  }
   /**
    * Watch for changes to external files. In particular, this awaits
    * modifications to any XSL files associated with XML files being edited. When
    * an XSL file is modified (external to the application), the snitch's ears
    * perk up and the file is reloaded. This keeps the XSL transformation up to
    * date with what's on the file system.
    */
   private void initSnitch() {
     getSnitch().addObserver( this );
+  }
   /**
    * Initialize the find input text field to listen on F3, ENTER, and ESCAPE key
    * presses.
    */
   private void initFindInput() {
     final TextField input = getFindTextField();
     input.setOnKeyPressed( ( KeyEvent event ) -> {
       switch( event.getCode() ) {
         case F3:
         case ENTER:
           findNext();
           break;
         case F:
           if( !event.isControlDown() ) {
             break;
+          }
         case ESCAPE:
           getStatusBar().setGraphic( null );
           getActiveFileEditor().getEditorPane().requestFocus();
           break;
+      }
     } );
     // Remove when the input field loses focus.
     input.focusedProperty().addListener(
+        (
             final ObservableValue<? extends Boolean> focused,
             final Boolean oFocus,
             final Boolean nFocus ) -> {
           if( !nFocus ) {
             getStatusBar().setGraphic( null );
+          }
+        }
     );
+  }
   /**
    * Listen for {@link FileEditorTabPane} to receive open definition file event.
    */
   private void initDefinitionListener() {
     getFileEditorPane().onOpenDefinitionFileProperty().addListener(
         ( final ObservableValue<? extends Path> file,
           final Path oldPath, final Path newPath ) -> {
           // Indirectly refresh the resolved map.
           resetProcessors();
           openDefinitions( newPath );
           // Will create new processors and therefore a new resolved map.
           refreshActiveTab();
+        }
     );
+  }
   /**
    * When tabs are added, hook the various change listeners onto the new tab so
    * that the preview pane refreshes as necessary.
    */
   private void initTabAddedListener() {
     final FileEditorTabPane editorPane = getFileEditorPane();
     // Make sure the text processor kicks off when new files are opened.
     final ObservableList<Tab> tabs = editorPane.getTabs();
     // Update the preview pane on tab changes.
     tabs.addListener(
         ( final Change<? extends Tab> change ) -> {
           while( change.next() ) {
             if( change.wasAdded() ) {
               // Multiple tabs can be added simultaneously.
               for( final Tab newTab : change.getAddedSubList() ) {
                 final FileEditorTab tab = (FileEditorTab) newTab;
                 initTextChangeListener( tab );
                 initCaretParagraphListener( tab );
                 initKeyboardEventListeners( tab );
 //              initSyntaxListener( tab );
+              }
+            }
+          }
+        }
     );
+  }
   /**
    * Reloads the preferences from the previous session.
    */
   private void initPreferences() {
     restoreDefinitionPane();
     getFileEditorPane().restorePreferences();
+  }
   /**
    * Listen for new tab selection events.
    */
   private void initTabChangedListener() {
     final FileEditorTabPane editorPane = getFileEditorPane();
     // Update the preview pane changing tabs.
     editorPane.addTabSelectionListener(
         ( ObservableValue<? extends Tab> tabPane,
           final Tab oldTab, final Tab newTab ) -> {
           updateVariableNameInjector();
           // If there was no old tab, then this is a first time load, which
           // can be ignored.
           if( oldTab != null ) {
             if( newTab == null ) {
               closeRemainingTab();
+            }
             else {
               // Update the preview with the edited text.
               refreshSelectedTab( (FileEditorTab) newTab );
+            }
+          }
+        }
     );
+  }
   /**
    * Ensure that the keyboard events are received when a new tab is added
    * to the user interface.
+   *
    * @param tab The tab that can trigger keyboard events, such as control+space.
    */
   private void initKeyboardEventListeners( final FileEditorTab tab ) {
     final VariableNameInjector vin = getVariableNameInjector();
     vin.initKeyboardEventListeners( tab );
+  }
   private void initTextChangeListener( final FileEditorTab tab ) {
     tab.addTextChangeListener(
         ( ObservableValue<? extends String> editor,
           final String oldValue, final String newValue ) ->
             refreshSelectedTab( tab )
     );
+  }
   private void initCaretParagraphListener( final FileEditorTab tab ) {
     tab.addCaretParagraphListener(
         ( ObservableValue<? extends Integer> editor,
           final Integer oldValue, final Integer newValue ) ->
             refreshSelectedTab( tab )
     );
+  }
   private void updateVariableNameInjector() {
     getVariableNameInjector().setFileEditorTab( getActiveFileEditor() );
+  }
   private void setVariableNameInjector( final VariableNameInjector injector ) {
     this.variableNameInjector = injector;
+  }
   private synchronized VariableNameInjector getVariableNameInjector() {
     if( this.variableNameInjector == null ) {
       final VariableNameInjector vin = createVariableNameInjector();
       setVariableNameInjector( vin );
+    }
     return this.variableNameInjector;
+  }
   private VariableNameInjector createVariableNameInjector() {
     final FileEditorTab tab = getActiveFileEditor();
     final DefinitionPane pane = getDefinitionPane();
     return new VariableNameInjector( tab, pane );
+  }
   /**
    * Called whenever the preview pane becomes out of sync with the file editor
    * tab. This can be called when the text changes, the caret paragraph changes,
    * or the file tab changes.
+   *
    * @param tab The file editor tab that has been changed in some fashion.
    */
   private void refreshSelectedTab( final FileEditorTab tab ) {
     if( tab == null ) {
       return;
+    }
     getPreviewPane().setPath( tab.getPath() );
     // TODO: https://github.com/DaveJarvis/scrivenvar/issues/29
     final Position p = tab.getCaretOffset();
     getLineNumberText().setText(
         get( STATUS_BAR_LINE,
              p.getMajor() + 1,
              p.getMinor() + 1,
              tab.getCaretPosition() + 1
+        )
     );
     Processor<String> processor = getProcessors().get( tab );
     if( processor == null ) {
       processor = createProcessor( tab );
       getProcessors().put( tab, processor );
+    }
     try {
       processor.processChain( tab.getEditorText() );
     } catch( final Exception ex ) {
       error( ex );
+    }
+  }
   private void refreshActiveTab() {
     refreshSelectedTab( getActiveFileEditor() );
+  }
   /**
    * Used to find text in the active file editor window.
    */
   private void find() {
     final TextField input = getFindTextField();
     getStatusBar().setGraphic( input );
     input.requestFocus();
+  }
   public void findNext() {
     getActiveFileEditor().searchNext( getFindTextField().getText() );
+  }
   /**
    * Returns the variable map of interpolated definitions.
+   *
    * @return A map to help dereference variables.
    */
   private Map<String, String> getResolvedMap() {
     return mResolvedMap;
+  }
   private void interpolateResolvedMap() {
     final Map<String, String> treeMap = getDefinitionPane().toMap();
     final Map<String, String> map = new HashMap<>( treeMap );
     MapInterpolator.interpolate( map );
     getResolvedMap().clear();
     getResolvedMap().putAll( map );
+  }
   /**
    * Called when a definition source is opened.
+   *
    * @param path Path to the definition source that was opened.
    */
   private void openDefinitions( final Path path ) {
     try {
       final DefinitionSource ds = createDefinitionSource( path );
       setDefinitionSource( ds );
       storeDefinitionSourceFilename( path );
       final DefinitionPane pane = getDefinitionPane();
       pane.update( ds );
       pane.addTreeChangeHandler( mHandler );
 import static javafx.scene.input.KeyCode.ENTER;
 import static javafx.scene.input.KeyCode.TAB;
 import static javafx.stage.WindowEvent.WINDOW_CLOSE_REQUEST;
 /**
  * Main window containing a tab pane in the center for file editors.
+ *
  * @author Karl Tauber and White Magic Software, Ltd.
  */
 public class MainWindow implements Observer {
   private final Options mOptions = Services.load( Options.class );
   private final Snitch mSnitch = Services.load( Snitch.class );
   private final Settings mSettings = Services.load( Settings.class );
   private final Notifier mNotifier = Services.load( Notifier.class );
   private final Scene mScene;
   private final StatusBar mStatusBar;
   private final Text mLineNumberText;
   private final TextField mFindTextField;
   private DefinitionSource mDefinitionSource = createDefaultDefinitionSource();
   private final DefinitionPane mDefinitionPane = new DefinitionPane();
   private final HTMLPreviewPane mPreviewPane = new HTMLPreviewPane();
   private FileEditorTabPane fileEditorPane;
   /**
    * Prevents re-instantiation of processing classes.
    */
   private final Map<FileEditorTab, Processor<String>> mProcessors =
       new HashMap<>();
   private final Map<String, String> mResolvedMap =
       new HashMap<>( DEFAULT_MAP_SIZE );
   /**
    * Listens on the definition pane for double-click events.
    */
   private VariableNameInjector variableNameInjector;
   /**
    * Called when the definition data is changed.
    */
   final EventHandler<TreeItem.TreeModificationEvent<Event>> mTreeHandler =
       event -> {
         exportDefinitions( getDefinitionPath() );
         interpolateResolvedMap();
         refreshActiveTab();
       };
   final EventHandler<? super KeyEvent> mDefinitionKeyHandler =
       event -> {
         if( event.getCode() == ENTER ) {
           getVariableNameInjector().injectSelectedItem();
+        }
       };
   final EventHandler<? super KeyEvent> mEditorKeyHandler =
       (EventHandler<KeyEvent>) event -> {
         if( event.getCode() == TAB ) {
           getDefinitionPane().requestFocus();
           event.consume();
+        }
       };
   public MainWindow() {
     mStatusBar = createStatusBar();
     mLineNumberText = createLineNumberText();
     mFindTextField = createFindTextField();
     mScene = createScene();
     initLayout();
     initFindInput();
     initSnitch();
     initDefinitionListener();
     initTabAddedListener();
     initTabChangedListener();
     initPreferences();
+  }
   /**
    * Watch for changes to external files. In particular, this awaits
    * modifications to any XSL files associated with XML files being edited. When
    * an XSL file is modified (external to the application), the snitch's ears
    * perk up and the file is reloaded. This keeps the XSL transformation up to
    * date with what's on the file system.
    */
   private void initSnitch() {
     getSnitch().addObserver( this );
+  }
   /**
    * Initialize the find input text field to listen on F3, ENTER, and ESCAPE key
    * presses.
    */
   private void initFindInput() {
     final TextField input = getFindTextField();
     input.setOnKeyPressed( ( KeyEvent event ) -> {
       switch( event.getCode() ) {
         case F3:
         case ENTER:
           findNext();
           break;
         case F:
           if( !event.isControlDown() ) {
             break;
+          }
         case ESCAPE:
           getStatusBar().setGraphic( null );
           getActiveFileEditor().getEditorPane().requestFocus();
           break;
+      }
     } );
     // Remove when the input field loses focus.
     input.focusedProperty().addListener(
+        (
             final ObservableValue<? extends Boolean> focused,
             final Boolean oFocus,
             final Boolean nFocus ) -> {
           if( !nFocus ) {
             getStatusBar().setGraphic( null );
+          }
+        }
     );
+  }
   /**
    * Listen for {@link FileEditorTabPane} to receive open definition file event.
    */
   private void initDefinitionListener() {
     getFileEditorPane().onOpenDefinitionFileProperty().addListener(
         ( final ObservableValue<? extends Path> file,
           final Path oldPath, final Path newPath ) -> {
           // Indirectly refresh the resolved map.
           resetProcessors();
           openDefinitions( newPath );
           // Will create new processors and therefore a new resolved map.
           refreshActiveTab();
+        }
     );
+  }
   /**
    * When tabs are added, hook the various change listeners onto the new tab so
    * that the preview pane refreshes as necessary.
    */
   private void initTabAddedListener() {
     final FileEditorTabPane editorPane = getFileEditorPane();
     // Make sure the text processor kicks off when new files are opened.
     final ObservableList<Tab> tabs = editorPane.getTabs();
     // Update the preview pane on tab changes.
     tabs.addListener(
         ( final Change<? extends Tab> change ) -> {
           while( change.next() ) {
             if( change.wasAdded() ) {
               // Multiple tabs can be added simultaneously.
               for( final Tab newTab : change.getAddedSubList() ) {
                 final FileEditorTab tab = (FileEditorTab) newTab;
                 initTextChangeListener( tab );
                 initCaretParagraphListener( tab );
                 initKeyboardEventListeners( tab );
 //              initSyntaxListener( tab );
+              }
+            }
+          }
+        }
     );
+  }
   /**
    * Reloads the preferences from the previous session.
    */
   private void initPreferences() {
     restoreDefinitionPane();
     getFileEditorPane().restorePreferences();
+  }
   /**
    * Listen for new tab selection events.
    */
   private void initTabChangedListener() {
     final FileEditorTabPane editorPane = getFileEditorPane();
     // Update the preview pane changing tabs.
     editorPane.addTabSelectionListener(
         ( ObservableValue<? extends Tab> tabPane,
           final Tab oldTab, final Tab newTab ) -> {
           updateVariableNameInjector();
           // If there was no old tab, then this is a first time load, which
           // can be ignored.
           if( oldTab != null ) {
             if( newTab == null ) {
               closeRemainingTab();
+            }
             else {
               // Update the preview with the edited text.
               refreshSelectedTab( (FileEditorTab) newTab );
+            }
+          }
+        }
     );
+  }
   /**
    * Ensure that the keyboard events are received when a new tab is added
    * to the user interface.
+   *
    * @param tab The tab that can trigger keyboard events, such as control+space.
    */
   private void initKeyboardEventListeners( final FileEditorTab tab ) {
     final VariableNameInjector vin = getVariableNameInjector();
     vin.initKeyboardEventListeners( tab );
     tab.addEventFilter( KeyEvent.KEY_PRESSED, mEditorKeyHandler );
+  }
   private void initTextChangeListener( final FileEditorTab tab ) {
     tab.addTextChangeListener(
         ( ObservableValue<? extends String> editor,
           final String oldValue, final String newValue ) ->
             refreshSelectedTab( tab )
     );
+  }
   private void initCaretParagraphListener( final FileEditorTab tab ) {
     tab.addCaretParagraphListener(
         ( ObservableValue<? extends Integer> editor,
           final Integer oldValue, final Integer newValue ) ->
             refreshSelectedTab( tab )
     );
+  }
   private void updateVariableNameInjector() {
     getVariableNameInjector().setFileEditorTab( getActiveFileEditor() );
+  }
   private void setVariableNameInjector( final VariableNameInjector injector ) {
     this.variableNameInjector = injector;
+  }
   private synchronized VariableNameInjector getVariableNameInjector() {
     if( this.variableNameInjector == null ) {
       final VariableNameInjector vin = createVariableNameInjector();
       setVariableNameInjector( vin );
+    }
     return this.variableNameInjector;
+  }
   private VariableNameInjector createVariableNameInjector() {
     final FileEditorTab tab = getActiveFileEditor();
     final DefinitionPane pane = getDefinitionPane();
     return new VariableNameInjector( tab, pane );
+  }
   /**
    * Called whenever the preview pane becomes out of sync with the file editor
    * tab. This can be called when the text changes, the caret paragraph changes,
    * or the file tab changes.
+   *
    * @param tab The file editor tab that has been changed in some fashion.
    */
   private void refreshSelectedTab( final FileEditorTab tab ) {
     if( tab == null ) {
       return;
+    }
     getPreviewPane().setPath( tab.getPath() );
     // TODO: https://github.com/DaveJarvis/scrivenvar/issues/29
     final Position p = tab.getCaretOffset();
     getLineNumberText().setText(
         get( STATUS_BAR_LINE,
              p.getMajor() + 1,
              p.getMinor() + 1,
              tab.getCaretPosition() + 1
+        )
     );
     Processor<String> processor = getProcessors().get( tab );
     if( processor == null ) {
       processor = createProcessor( tab );
       getProcessors().put( tab, processor );
+    }
     try {
       processor.processChain( tab.getEditorText() );
     } catch( final Exception ex ) {
       error( ex );
+    }
+  }
   private void refreshActiveTab() {
     refreshSelectedTab( getActiveFileEditor() );
+  }
   /**
    * Used to find text in the active file editor window.
    */
   private void find() {
     final TextField input = getFindTextField();
     getStatusBar().setGraphic( input );
     input.requestFocus();
+  }
   public void findNext() {
     getActiveFileEditor().searchNext( getFindTextField().getText() );
+  }
   /**
    * Returns the variable map of interpolated definitions.
+   *
    * @return A map to help dereference variables.
    */
   private Map<String, String> getResolvedMap() {
     return mResolvedMap;
+  }
   private void interpolateResolvedMap() {
     final Map<String, String> treeMap = getDefinitionPane().toMap();
     final Map<String, String> map = new HashMap<>( treeMap );
     MapInterpolator.interpolate( map );
     getResolvedMap().clear();
     getResolvedMap().putAll( map );
+  }
   /**
    * Called when a definition source is opened.
+   *
    * @param path Path to the definition source that was opened.
    */
   private void openDefinitions( final Path path ) {
     try {
       final DefinitionSource ds = createDefinitionSource( path );
       setDefinitionSource( ds );
       storeDefinitionSourceFilename( path );
       final DefinitionPane pane = getDefinitionPane();
       pane.update( ds );
       pane.addTreeChangeHandler( mTreeHandler );
       pane.addKeyEventHandler( mDefinitionKeyHandler );
       interpolateResolvedMap();

M src/main/java/com/scrivenvar/decorators/YamlVariableDecorator.java

 package com.scrivenvar.decorators;
 import java.util.regex.Pattern;
 /**
  * Brackets variable names with dollar symbols.
+ *
  * @author White Magic Software, Ltd.
  */
 public class YamlVariableDecorator implements VariableDecorator {
   /**
    * Matches variables delimited by dollar symbols. The outer group is necessary
    * for substring replacement of delimited references.
    */
   public final static String REGEX = "(\\$(.*?)\\$)";
   /**
    * Compiled regular expression for matching delimited references.
    */
   public final static Pattern REGEX_PATTERN = Pattern.compile( REGEX );
   /**

M src/main/java/com/scrivenvar/definition/DefinitionPane.java

 import javafx.util.StringConverter;
 import java.util.LinkedList;
 import java.util.List;
 import java.util.Map;
 import static com.scrivenvar.Messages.get;
 import static javafx.scene.input.KeyEvent.KEY_PRESSED;
 /**
  * Provides the user interface that holdsa {@link TreeView}, which
  * allows users to interact with key/value pairs loaded from the
  * {@link DocumentParser} and adapted using a {@link TreeAdapter}.
+ *
  * @author White Magic Software, Ltd.
  */
 public final class DefinitionPane extends AbstractPane {
   /**
    * Trimmed off the end of a word to match a variable name.
    */
   private final static String TERMINALS = ":;,.!?-/\\¡¿";
   /**
    * Contains a view of the definitions.
    */
   private final TreeView<String> mTreeView = new TreeView<>();
   /**
    * Constructs a definition pane with a given tree view root.
    */
   public DefinitionPane() {
     final var treeView = getTreeView();
     treeView.setEditable( true );
     treeView.setCellFactory( cell -> createTreeCell() );
     treeView.setContextMenu( createContextMenu() );
     treeView.addEventFilter( KEY_PRESSED, this::keyEventFilter );
     treeView.setShowRoot( false );
     getSelectionModel().setSelectionMode( SelectionMode.MULTIPLE );
+  }
   /**
    * Changes the root of the {@link TreeView} to the root of the
    * {@link TreeView} from the {@link DefinitionSource}.
+   *
    * @param definitionSource Container for the hierarchy of key/value pairs
    *                         to replace the existing hierarchy.
    */
   public void update( final DefinitionSource definitionSource ) {
     assert definitionSource != null;
     final TreeAdapter treeAdapter = definitionSource.getTreeAdapter();
     final TreeItem<String> root = treeAdapter.adapt(
         get( "Pane.definition.node.root.title" )
     );
     getTreeView().setRoot( root );
+  }
   public Map<String, String> toMap() {
     return TreeItemAdapter.toMap( getTreeView().getRoot() );
+  }
   /**
    * Informs the caller of whenever any {@link TreeItem} in the {@link TreeView}
    * is modified. The modifications include: item value changes, item additions,
    * and item removals.
    * <p>
    * Safe to call multiple times; if a handler is already registered, the
    * old handler is used.
    * </p>
+   *
    * @param handler The handler to call whenever any {@link TreeItem} changes.
    */
   public void addTreeChangeHandler(
       final EventHandler<TreeItem.TreeModificationEvent<Event>> handler ) {
     final TreeItem<String> root = getTreeView().getRoot();
     root.addEventHandler( TreeItem.valueChangedEvent(), handler );
     root.addEventHandler( TreeItem.childrenModificationEvent(), handler );
+  }
   /**
    * Answers whether the {@link TreeItem}s in the {@link TreeView} are suitably
    * well-formed for export. A tree is considered well-formed if the following
    * conditions are met:
+   *
    * <ul>
    *   <li>The root node contains at least one child node having a leaf.</li>
    *   <li>There are no leaf nodes with sibling leaf nodes.</li>
    * </ul>
+   *
    * @return {@code null} if the document is well-formed, otherwise the
    * problematic child {@link TreeItem}.
    */
   public TreeItem<String> isTreeWellFormed() {
     final var root = getTreeView().getRoot();
     for( final var child : root.getChildren() ) {
       final var problemChild = isWellFormed( child );
       if( child.isLeaf() || problemChild != null ) {
         return problemChild;
+      }
+    }
     return null;
+  }
   /**
    * Determines whether the document is well-formed by ensuring that
    * child branches do not contain multiple leaves.
+   *
    * @param item The sub-tree to check for well-formedness.
    * @return {@code null} when the tree is well-formed, otherwise the
    * problematic {@link TreeItem}.
    */
   private TreeItem<String> isWellFormed( final TreeItem<String> item ) {
     int childLeafs = 0;
     int childBranches = 0;
     for( final TreeItem<String> child : item.getChildren() ) {
       if( child.isLeaf() ) {
         childLeafs++;
+      }
       else {
         childBranches++;
+      }
       final var problemChild = isWellFormed( child );
       if( problemChild != null ) {
         return problemChild;
+      }
+    }
     return ((childBranches > 0 && childLeafs == 0) ||
         (childBranches == 0 && childLeafs <= 1)) ? null : item;
+  }
   /**
    * Returns the leaf that matches the given value. If the value is terminally
    * punctuated, the punctuation is removed if no match was found.
+   *
    * @param value    The value to find, never null.
    * @param findMode Defines how to match words.
    * @return The leaf that contains the given value, or null if neither the
    * original value nor the terminally-trimmed value was found.
    */
   public VariableTreeItem<String> findLeaf(
       final String value, final FindMode findMode ) {
     final VariableTreeItem<String> root = getTreeRoot();
     final VariableTreeItem<String> leaf = root.findLeaf( value, findMode );
     return leaf == null
         ? root.findLeaf( rtrimTerminalPunctuation( value ) )
         : leaf;
+  }
   /**
    * Removes punctuation from the end of a string.
+   *
    * @param s The string to trim, never null.
    * @return The string trimmed of all terminal characters from the end
    */
   private String rtrimTerminalPunctuation( final String s ) {
     assert s != null;
     int index = s.length() - 1;
     while( index > 0 && (TERMINALS.indexOf( s.charAt( index ) ) >= 0) ) {
       index--;
+    }
     return s.substring( 0, index );
+  }
   /**
    * Expands the node to the root, recursively.
+   *
    * @param <T>  The type of tree item to expand (usually String).
    * @param node The node to expand.
    */
   public <T> void expand( final TreeItem<T> node ) {
     if( node != null ) {
       expand( node.getParent() );
       if( !node.isLeaf() ) {
         node.setExpanded( true );
+      }
+    }
+  }
   public void select( final TreeItem<String> item ) {
     getSelectionModel().clearSelection();
     getSelectionModel().select( getTreeView().getRow( item ) );
+  }
   /**
    * Collapses the tree, recursively.
    */
   public void collapse() {
     collapse( getTreeRoot().getChildren() );
+  }
   /**
    * Collapses the tree, recursively.
+   *
    * @param <T>   The type of tree item to expand (usually String).
    * @param nodes The nodes to collapse.
    */
   private <T> void collapse( final ObservableList<TreeItem<T>> nodes ) {
     for( final TreeItem<T> node : nodes ) {
       node.setExpanded( false );
       collapse( node.getChildren() );
+    }
+  }
   /**
    * @return {@code true} when the user is editing a {@link TreeItem}.
    */
   private boolean isEditingTreeItem() {
     return getTreeView().editingItemProperty().getValue() != null;
+  }
   /**
    * Changes to edit mode for the selected item.
    */
   private void editSelectedItem() {
     getTreeView().edit( getSelectedItem() );
+  }
   /**
    * Removes all selected items from the {@link TreeView}.
    */
   private void deleteSelectedItems() {
     for( final TreeItem<String> item : getSelectedItems() ) {
       final TreeItem<String> parent = item.getParent();
       if( parent != null ) {
         parent.getChildren().remove( item );
+      }
+    }
+  }
   /**
    * Deletes the selected item.
    */
   private void deleteSelectedItem() {
     final TreeItem<String> c = getSelectedItem();
     getSiblings( c ).remove( c );
+  }
   /**
    * Adds a new item under the selected item (or root if nothing is selected).
    * There are a few conditions to consider: when adding to the root,
    * when adding to a leaf, and when adding to a non-leaf. Items added to the
    * root must contain two items: a key and a value.
    */
   private void addItem() {
     final TreeItem<String> value = createTreeItem();
     getSelectedItem().getChildren().add( value );
     expand( value );
     select( value );
+  }
   private ContextMenu createContextMenu() {
     final ContextMenu menu = new ContextMenu();
     final ObservableList<MenuItem> items = menu.getItems();
     addMenuItem( items, "Definition.menu.create" )
         .setOnAction( e -> addItem() );
     addMenuItem( items, "Definition.menu.rename" )
         .setOnAction( e -> editSelectedItem() );
     addMenuItem( items, "Definition.menu.remove" )
         .setOnAction( e -> deleteSelectedItem() );
     return menu;
+  }
   /**
    * Executes hot-keys for edits to the definition tree.
+   *
    * @param event Contains the key code of the key that was pressed.
    */
   private void keyEventFilter( final KeyEvent event ) {
     if( !isEditingTreeItem() ) {
       switch( event.getCode() ) {
         case ENTER:
           expand( getSelectedItem() );
           event.consume();
           break;
         case DELETE:
           deleteSelectedItems();
           break;
         case INSERT:
           addItem();
           break;
         case R:
           if( event.isControlDown() ) {
             editSelectedItem();
+          }
           break;
+      }
+    }
+  }
   /**
    * Adds a menu item to a list of menu items.
+   *
    * @param items    The list of menu items to append to.
    * @param labelKey The resource bundle key name for the menu item's label.
    * @return The menu item added to the list of menu items.
    */
   private MenuItem addMenuItem(
       final List<MenuItem> items, final String labelKey ) {
     final MenuItem menuItem = createMenuItem( labelKey );
     items.add( menuItem );
     return menuItem;
+  }
   private MenuItem createMenuItem( final String labelKey ) {
     return new MenuItem( get( labelKey ) );
+  }
   private VariableTreeItem<String> createTreeItem() {
     return new VariableTreeItem<>( get( "Definition.menu.add.default" ) );
+  }
   private TreeCell<String> createTreeCell() {
     return new TextFieldTreeCell<>(
         createStringConverter() ) {
       @Override
       public void commitEdit( final String newValue ) {
         super.commitEdit( newValue );
         requestFocus();
         select( getTreeItem() );
+      }
     };
+  }
   private StringConverter<String> createStringConverter() {
     return new StringConverter<>() {
       @Override
       public String toString( final String object ) {
         return object == null ? "" : object;
+      }
       @Override
       public String fromString( final String string ) {
         return string == null ? "" : string;
+      }
     };
+  }
   /**
    * Returns the tree view that contains the definition hierarchy.
+   *
    * @return A non-null instance.
    */
   public TreeView<String> getTreeView() {
     return mTreeView;
+  }
   /**
    * Returns the root node to the tree view.
+   *
    * @return getTreeView()
    */
   public Node getNode() {
     return getTreeView();
+  }
   /**
    * Returns the root of the tree.
+   *
    * @return The first node added to the definition tree.
    */
   private VariableTreeItem<String> getTreeRoot() {
     final TreeItem<String> root = getTreeView().getRoot();
     return root instanceof VariableTreeItem ?
         (VariableTreeItem<String>) root : new VariableTreeItem<>( "root" );
+  }
   private ObservableList<TreeItem<String>> getSiblings(
       final TreeItem<String> item ) {
     final TreeItem<String> root = getTreeView().getRoot();
     final TreeItem<String> parent =
         (item == null || item == root) ? root : item.getParent();
     return parent.getChildren();
+  }
   private MultipleSelectionModel<TreeItem<String>> getSelectionModel() {
     return getTreeView().getSelectionModel();
+  }
   /**
    * Returns a copy of all the selected items.
+   *
    * @return A list, possibly empty, containing all selected items in the
    * {@link TreeView}.
    */
   private List<TreeItem<String>> getSelectedItems() {
     return new LinkedList<>( getSelectionModel().getSelectedItems() );
+  }
   private TreeItem<String> getSelectedItem() {
     final TreeItem<String> item = getSelectionModel().getSelectedItem();
     return item == null ? getTreeView().getRoot() : item;
 import java.util.*;
 import static com.scrivenvar.Messages.get;
 import static javafx.scene.input.KeyEvent.KEY_PRESSED;
 /**
  * Provides the user interface that holdsa {@link TreeView}, which
  * allows users to interact with key/value pairs loaded from the
  * {@link DocumentParser} and adapted using a {@link TreeAdapter}.
+ *
  * @author White Magic Software, Ltd.
  */
 public final class DefinitionPane extends AbstractPane {
   /**
    * Trimmed off the end of a word to match a variable name.
    */
   private final static String TERMINALS = ":;,.!?-/\\¡¿";
   /**
    * Contains a view of the definitions.
    */
   private final TreeView<String> mTreeView = new TreeView<>();
   /**
    * Handlers for key press events.
    */
   private final Set<EventHandler<? super KeyEvent>> mKeyEventHandlers
       = new HashSet<>();
   /**
    * Constructs a definition pane with a given tree view root.
    */
   public DefinitionPane() {
     final var treeView = getTreeView();
     treeView.setEditable( true );
     treeView.setCellFactory( cell -> createTreeCell() );
     treeView.setContextMenu( createContextMenu() );
     treeView.addEventFilter( KEY_PRESSED, this::keyEventFilter );
     treeView.setShowRoot( false );
     getSelectionModel().setSelectionMode( SelectionMode.MULTIPLE );
+  }
   /**
    * Changes the root of the {@link TreeView} to the root of the
    * {@link TreeView} from the {@link DefinitionSource}.
+   *
    * @param definitionSource Container for the hierarchy of key/value pairs
    *                         to replace the existing hierarchy.
    */
   public void update( final DefinitionSource definitionSource ) {
     assert definitionSource != null;
     final TreeAdapter treeAdapter = definitionSource.getTreeAdapter();
     final TreeItem<String> root = treeAdapter.adapt(
         get( "Pane.definition.node.root.title" )
     );
     getTreeView().setRoot( root );
+  }
   public Map<String, String> toMap() {
     return TreeItemAdapter.toMap( getTreeView().getRoot() );
+  }
   /**
    * Informs the caller of whenever any {@link TreeItem} in the {@link TreeView}
    * is modified. The modifications include: item value changes, item additions,
    * and item removals.
    * <p>
    * Safe to call multiple times; if a handler is already registered, the
    * old handler is used.
    * </p>
+   *
    * @param handler The handler to call whenever any {@link TreeItem} changes.
    */
   public void addTreeChangeHandler(
       final EventHandler<TreeItem.TreeModificationEvent<Event>> handler ) {
     final TreeItem<String> root = getTreeView().getRoot();
     root.addEventHandler( TreeItem.valueChangedEvent(), handler );
     root.addEventHandler( TreeItem.childrenModificationEvent(), handler );
+  }
   public void addKeyEventHandler(
       final EventHandler<? super KeyEvent> handler ) {
     getKeyEventHandlers().add( handler );
+  }
   /**
    * Answers whether the {@link TreeItem}s in the {@link TreeView} are suitably
    * well-formed for export. A tree is considered well-formed if the following
    * conditions are met:
+   *
    * <ul>
    *   <li>The root node contains at least one child node having a leaf.</li>
    *   <li>There are no leaf nodes with sibling leaf nodes.</li>
    * </ul>
+   *
    * @return {@code null} if the document is well-formed, otherwise the
    * problematic child {@link TreeItem}.
    */
   public TreeItem<String> isTreeWellFormed() {
     final var root = getTreeView().getRoot();
     for( final var child : root.getChildren() ) {
       final var problemChild = isWellFormed( child );
       if( child.isLeaf() || problemChild != null ) {
         return problemChild;
+      }
+    }
     return null;
+  }
   /**
    * Determines whether the document is well-formed by ensuring that
    * child branches do not contain multiple leaves.
+   *
    * @param item The sub-tree to check for well-formedness.
    * @return {@code null} when the tree is well-formed, otherwise the
    * problematic {@link TreeItem}.
    */
   private TreeItem<String> isWellFormed( final TreeItem<String> item ) {
     int childLeafs = 0;
     int childBranches = 0;
     for( final TreeItem<String> child : item.getChildren() ) {
       if( child.isLeaf() ) {
         childLeafs++;
+      }
       else {
         childBranches++;
+      }
       final var problemChild = isWellFormed( child );
       if( problemChild != null ) {
         return problemChild;
+      }
+    }
     return ((childBranches > 0 && childLeafs == 0) ||
         (childBranches == 0 && childLeafs <= 1)) ? null : item;
+  }
   /**
    * Returns the leaf that matches the given value. If the value is terminally
    * punctuated, the punctuation is removed if no match was found.
+   *
    * @param value    The value to find, never null.
    * @param findMode Defines how to match words.
    * @return The leaf that contains the given value, or null if neither the
    * original value nor the terminally-trimmed value was found.
    */
   public VariableTreeItem<String> findLeaf(
       final String value, final FindMode findMode ) {
     final VariableTreeItem<String> root = getTreeRoot();
     final VariableTreeItem<String> leaf = root.findLeaf( value, findMode );
     return leaf == null
         ? root.findLeaf( rtrimTerminalPunctuation( value ) )
         : leaf;
+  }
   /**
    * Removes punctuation from the end of a string.
+   *
    * @param s The string to trim, never null.
    * @return The string trimmed of all terminal characters from the end
    */
   private String rtrimTerminalPunctuation( final String s ) {
     assert s != null;
     int index = s.length() - 1;
     while( index > 0 && (TERMINALS.indexOf( s.charAt( index ) ) >= 0) ) {
       index--;
+    }
     return s.substring( 0, index );
+  }
   /**
    * Expands the node to the root, recursively.
+   *
    * @param <T>  The type of tree item to expand (usually String).
    * @param node The node to expand.
    */
   public <T> void expand( final TreeItem<T> node ) {
     if( node != null ) {
       expand( node.getParent() );
       if( !node.isLeaf() ) {
         node.setExpanded( true );
+      }
+    }
+  }
   public void select( final TreeItem<String> item ) {
     getSelectionModel().clearSelection();
     getSelectionModel().select( getTreeView().getRow( item ) );
+  }
   /**
    * Collapses the tree, recursively.
    */
   public void collapse() {
     collapse( getTreeRoot().getChildren() );
+  }
   /**
    * Collapses the tree, recursively.
+   *
    * @param <T>   The type of tree item to expand (usually String).
    * @param nodes The nodes to collapse.
    */
   private <T> void collapse( final ObservableList<TreeItem<T>> nodes ) {
     for( final TreeItem<T> node : nodes ) {
       node.setExpanded( false );
       collapse( node.getChildren() );
+    }
+  }
   /**
    * @return {@code true} when the user is editing a {@link TreeItem}.
    */
   private boolean isEditingTreeItem() {
     return getTreeView().editingItemProperty().getValue() != null;
+  }
   /**
    * Changes to edit mode for the selected item.
    */
   private void editSelectedItem() {
     getTreeView().edit( getSelectedItem() );
+  }
   /**
    * Removes all selected items from the {@link TreeView}.
    */
   private void deleteSelectedItems() {
     for( final TreeItem<String> item : getSelectedItems() ) {
       final TreeItem<String> parent = item.getParent();
       if( parent != null ) {
         parent.getChildren().remove( item );
+      }
+    }
+  }
   /**
    * Deletes the selected item.
    */
   private void deleteSelectedItem() {
     final TreeItem<String> c = getSelectedItem();
     getSiblings( c ).remove( c );
+  }
   /**
    * Adds a new item under the selected item (or root if nothing is selected).
    * There are a few conditions to consider: when adding to the root,
    * when adding to a leaf, and when adding to a non-leaf. Items added to the
    * root must contain two items: a key and a value.
    */
   private void addItem() {
     final TreeItem<String> value = createTreeItem();
     getSelectedItem().getChildren().add( value );
     expand( value );
     select( value );
+  }
   private ContextMenu createContextMenu() {
     final ContextMenu menu = new ContextMenu();
     final ObservableList<MenuItem> items = menu.getItems();
     addMenuItem( items, "Definition.menu.create" )
         .setOnAction( e -> addItem() );
     addMenuItem( items, "Definition.menu.rename" )
         .setOnAction( e -> editSelectedItem() );
     addMenuItem( items, "Definition.menu.remove" )
         .setOnAction( e -> deleteSelectedItem() );
     return menu;
+  }
   /**
    * Executes hot-keys for edits to the definition tree.
+   *
    * @param event Contains the key code of the key that was pressed.
    */
   private void keyEventFilter( final KeyEvent event ) {
     if( !isEditingTreeItem() ) {
       switch( event.getCode() ) {
         case ENTER:
           expand( getSelectedItem() );
           event.consume();
           break;
         case DELETE:
           deleteSelectedItems();
           break;
         case INSERT:
           addItem();
           break;
         case R:
           if( event.isControlDown() ) {
             editSelectedItem();
+          }
           break;
+      }
       for( final var handler : getKeyEventHandlers() ) {
         handler.handle( event );
+      }
+    }
+  }
   /**
    * Adds a menu item to a list of menu items.
+   *
    * @param items    The list of menu items to append to.
    * @param labelKey The resource bundle key name for the menu item's label.
    * @return The menu item added to the list of menu items.
    */
   private MenuItem addMenuItem(
       final List<MenuItem> items, final String labelKey ) {
     final MenuItem menuItem = createMenuItem( labelKey );
     items.add( menuItem );
     return menuItem;
+  }
   private MenuItem createMenuItem( final String labelKey ) {
     return new MenuItem( get( labelKey ) );
+  }
   private VariableTreeItem<String> createTreeItem() {
     return new VariableTreeItem<>( get( "Definition.menu.add.default" ) );
+  }
   private TreeCell<String> createTreeCell() {
     return new TextFieldTreeCell<>(
         createStringConverter() ) {
       @Override
       public void commitEdit( final String newValue ) {
         super.commitEdit( newValue );
         select( getTreeItem() );
         requestFocus();
+      }
     };
+  }
   @Override
   public void requestFocus() {
     super.requestFocus();
     getTreeView().requestFocus();
+  }
   private StringConverter<String> createStringConverter() {
     return new StringConverter<>() {
       @Override
       public String toString( final String object ) {
         return object == null ? "" : object;
+      }
       @Override
       public String fromString( final String string ) {
         return string == null ? "" : string;
+      }
     };
+  }
   /**
    * Returns the tree view that contains the definition hierarchy.
+   *
    * @return A non-null instance.
    */
   public TreeView<String> getTreeView() {
     return mTreeView;
+  }
   /**
    * Returns the root node to the tree view.
+   *
    * @return getTreeView()
    */
   public Node getNode() {
     return getTreeView();
+  }
   /**
    * Returns the root of the tree.
+   *
    * @return The first node added to the definition tree.
    */
   private VariableTreeItem<String> getTreeRoot() {
     final TreeItem<String> root = getTreeView().getRoot();
     return root instanceof VariableTreeItem ?
         (VariableTreeItem<String>) root : new VariableTreeItem<>( "root" );
+  }
   private ObservableList<TreeItem<String>> getSiblings(
       final TreeItem<String> item ) {
     final TreeItem<String> root = getTreeView().getRoot();
     final TreeItem<String> parent =
         (item == null || item == root) ? root : item.getParent();
     return parent.getChildren();
+  }
   private MultipleSelectionModel<TreeItem<String>> getSelectionModel() {
     return getTreeView().getSelectionModel();
+  }
   /**
    * Returns a copy of all the selected items.
+   *
    * @return A list, possibly empty, containing all selected items in the
    * {@link TreeView}.
    */
   private List<TreeItem<String>> getSelectedItems() {
     return new LinkedList<>( getSelectionModel().getSelectedItems() );
+  }
   public TreeItem<String> getSelectedItem() {
     final TreeItem<String> item = getSelectionModel().getSelectedItem();
     return item == null ? getTreeView().getRoot() : item;
+  }
   private Set<EventHandler<? super KeyEvent>> getKeyEventHandlers() {
     return mKeyEventHandlers;
+  }
+}

M src/main/java/com/scrivenvar/definition/FindMode.java

  */
 public enum FindMode {
   EXACT,
   CONTAINS,
   STARTS_WITH,

M src/main/java/com/scrivenvar/definition/MapInterpolator.java

 package com.scrivenvar.definition;
 import com.scrivenvar.decorators.YamlVariableDecorator;
 import java.util.Map;
 import java.util.regex.Matcher;
 import static com.scrivenvar.decorators.YamlVariableDecorator.REGEX_PATTERN;
 import java.util.regex.Pattern;
 /**
  * Responsible for performing string interpolation on key/value pairs stored
  * in a map. The values in the map can use a delimited syntax to refer to
  * keys in the map.
+ *
  * @author White Magic Software, Ltd.
  */
 public class MapInterpolator {
   /**
    * Matches variables delimited by dollar symbols.
    */
   private final static String REGEX = "(\\$.*?\\$)";
   /**
    * Compiled regular expression for matching delimited references.
    */
   private final static Pattern REGEX_PATTERN = Pattern.compile( REGEX );
   private final static int GROUP_DELIMITED = 1;
    * Performs string interpolation on the values in the given map. This will
    * change any value in the map that contains a variable that matches
    * {@link YamlVariableDecorator#REGEX_PATTERN}.
    * {@link #REGEX_PATTERN}.
+   *
    * @param map Contains values that represent references to keys.
     while( matcher.find() ) {
       final String keyName = matcher.group( GROUP_DELIMITED );
       final String keyValue = resolve(
           map, map.getOrDefault( keyName, keyName )

M src/main/java/com/scrivenvar/definition/TreeItemAdapter.java

 public class TreeItemAdapter {
   /**
    * Separates YAML variable nodes (e.g., the dots in {@code $root.node.var$]).
    * Separates YAML variable nodes (e.g., the dots in {@code $root.node.var$}).
    */
   public static final String SEPARATOR = ".";

M src/main/java/com/scrivenvar/definition/VariableTreeItem.java

 import java.util.Stack;
 import static com.scrivenvar.definition.FindMode.CONTAINS;
 import static com.scrivenvar.definition.FindMode.STARTS_WITH;
 import static com.scrivenvar.definition.FindMode.*;
 import static java.text.Normalizer.Form.NFD;
       node = stack.pop();
       if( findMode == CONTAINS && node.valueContains( text ) ) {
       if( findMode == EXACT && node.valueEquals( text ) ) {
         found = true;
+      }
       else if( findMode == CONTAINS && node.valueContains( text ) ) {
         found = true;
+      }
   private boolean valueContains( final String s ) {
     return isLeaf() && getDiacriticlessValue().contains( s );
+  }
   /**
    * Returns true if this node is a leaf and its value equals the given text.
+   *
    * @param s The text to compare against the node value.
    * @return true Node is a leaf and its value equals the given value.
    */
   private boolean valueEquals( final String s ) {
     return isLeaf() && getValue().equals( s );
+  }

M src/main/java/com/scrivenvar/editors/VariableNameInjector.java

   /**
    * Inserts the variable
    */
   public void injectSelectedItem() {
     final TreeItem<String> item = getDefinitionPane().getSelectedItem();
     if( item.isLeaf() ) {
       // This avoids a direct typecast.
       final VariableTreeItem<String> leaf = getDefinitionPane().findLeaf(
           item.getValue(), FindMode.EXACT );
       final StyledTextArea<?, ?> editor = getEditor();
       editor.insertText( editor.getCaretPosition(), decorate( leaf ) );
+    }
+  }
   /**
    * Traps Control+SPACE to auto-insert definition key names.
    */
     if( leaf != null ) {
       replaceText(
           boundaries[ 0 ],
           boundaries[ 1 ],
           decorate( leaf.toPath() )
       );
       replaceText( boundaries[ 0 ], boundaries[ 1 ], decorate( leaf ) );
       expand( leaf );
+    }
   /**
    * Injects a variable using the syntax specific to the type of document
    * Decorates a {@link TreeItem} using the syntax specific to the type of
    * document being edited.
+   *
    * @param leaf The path to the leaf (the definition key) to be decorated.
    */
   private String decorate( final VariableTreeItem<String> leaf ) {
     return decorate( leaf.toPath() );
+  }
   /**
    * Decorates a variable using the syntax specific to the type of document
    * being edited.
+   *
    * @param variable The variable to decorate in dot-notation without any
    *                 start or end tokens present.
    *                 start or end sigils present.
    */
   private String decorate( final String variable ) {
     assert word != null;
     VariableTreeItem<String> leaf;
     VariableTreeItem<String> leaf = findLeafExact( word );
     leaf = findLeafStartsWith( word );
     leaf = leaf == null ? findLeafStartsWith( word ) : leaf;
     leaf = leaf == null ? findLeafContains( word ) : leaf;
     leaf = leaf == null ? findLeafLevenshtein( word ) : leaf;
     return leaf;
+  }
   private VariableTreeItem<String> findLeafExact( final String text ) {
     return findLeaf( text, EXACT );
+  }

A src/main/resources/com/scrivenvar/.gitignore

	1	app.properties
1	2

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

 Main.menu.insert.header_3=Header 3
 Main.menu.insert.header_3.prompt=header 3
 Main.menu.insert.header_4=Header 4
 Main.menu.insert.header_4.prompt=header 4
 Main.menu.insert.header_5=Header 5
 Main.menu.insert.header_5.prompt=header 5
 Main.menu.insert.header_6=Header 6
 Main.menu.insert.header_6.prompt=header 6
 Main.menu.insert.unordered_list=Unordered List
 Main.menu.insert.ordered_list=Ordered List