Dave Jarvis' Repositories

Home Files Commits Tags Clone

Repository:

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

M README.md

 Usage
 ---
 . [Download](https://github.com/DaveJarvis/scrivenvar/releases) the jar file.
 . [Download](https://github.com/DaveJarvis/scrivenvar/releases) `scrivenvar.jar`.
 . Double-click `scrivenvar.jar` to start the application.

M build.gradle

+}
 version = '1.1.6'
 version = '1.2.0'
 applicationName = 'scrivenvar'
 mainClassName = 'com.scrivenvar.Main'
 sourceCompatibility = JavaVersion.VERSION_1_8
 jar {
   baseName = applicationName
   archiveName = "${applicationName}.jar"
   doFirst {

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

 import com.scrivenvar.service.events.Notifier;
 import java.nio.charset.Charset;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import static java.util.Locale.ENGLISH;
 import java.util.function.Consumer;
 import javafx.application.Platform;
 import javafx.beans.binding.Bindings;
 import javafx.beans.property.BooleanProperty;
 import javafx.beans.property.ReadOnlyBooleanProperty;
 import javafx.beans.property.ReadOnlyBooleanWrapper;
 import javafx.beans.property.SimpleBooleanProperty;
 import javafx.beans.value.ChangeListener;
 import javafx.beans.value.ObservableValue;
 import javafx.event.Event;
 import javafx.scene.Node;
 import javafx.scene.control.Tab;
 import javafx.scene.control.Tooltip;
 import javafx.scene.input.InputEvent;
 import javafx.scene.text.Text;
 import javafx.stage.Window;
 import org.fxmisc.richtext.StyleClassedTextArea;
 import static org.fxmisc.richtext.model.TwoDimensional.Bias.Forward;
 import org.fxmisc.richtext.model.TwoDimensional.Position;
 import org.fxmisc.undo.UndoManager;
 import org.fxmisc.wellbehaved.event.EventPattern;
 import org.fxmisc.wellbehaved.event.InputMap;
 import org.mozilla.universalchardet.UniversalDetector;
 /**
  * Editor for a single file.
+ *
  * @author Karl Tauber and White Magic Software, Ltd.
  */
 public final class FileEditorTab extends Tab {
   private final Notifier alertService = Services.load( Notifier.class );
   private EditorPane editorPane;
   /**
    * Character encoding used by the file (or default encoding if none found).
    */
   private Charset encoding;
   private final ReadOnlyBooleanWrapper modified = new ReadOnlyBooleanWrapper();
   private final BooleanProperty canUndo = new SimpleBooleanProperty();
   private final BooleanProperty canRedo = new SimpleBooleanProperty();
   // Might be simpler to revert this back to a property and have the main
   // window listen for changes to it...
   private Path path;
   FileEditorTab( final Path path ) {
     setPath( path );
     this.modified.addListener( (observable, oldPath, newPath) -> updateTab() );
     updateTab();
     setOnSelectionChanged( e -> {
       if( isSelected() ) {
         Platform.runLater( () -> 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() {
     final Path filePath = getPath();
     return (filePath == null)
       ? Messages.get( "FileEditor.untitled" )
       : filePath.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();
     // Clear undo history after first load.
     undoManager.forgetHistory();
     // Bind the editor undo manager to the properties.
     modified.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, 0 );
+    }
     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 ? false : filePath.equals( check );
+  }
   /**
    * Reads the entire file contents from the path associated with this tab.
    */
   private void load() {
     final Path filePath = getPath();
     if( filePath != null ) {
       try {
         getEditorPane().setText( asString( Files.readAllBytes( filePath ) ) );
       } catch( final Exception ex ) {
         getNotifyService().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 {
       Files.write( getPath(), asBytes( getEditorPane().getText() ) );
       getEditorPane().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
    */
   private boolean alert(
     final String titleKey, final String messageKey, final Exception e ) {
     final Notifier service = getNotifyService();
     final Path filePath = getPath();
     final Notification message = service.createNotification(
       Messages.get( titleKey ),
       Messages.get( messageKey ),
       filePath == null ? "" : filePath,
       e.getMessage()
     );
     service.createError( getWindow(), message ).showAndWait();
     return false;
+  }
   private Window getWindow() {
     return getEditorPane().getScene().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() );
+  }
   public Path getPath() {
     return this.path;
+  }
   public void setPath( final Path path ) {
     this.path = path;
+  }
   /**
    * Answers whether this tab has an initialized path reference.
+   *
    * @return false This tab has no path.
    */
   public boolean isFileOpen() {
     return this.path != null;
+  }
   public boolean isModified() {
     return this.modified.get();
+  }
   ReadOnlyBooleanProperty modifiedProperty() {
     return this.modified.getReadOnlyProperty();
+  }
   BooleanProperty canUndoProperty() {
     return this.canUndo;
+  }
   BooleanProperty canRedoProperty() {
     return this.canRedo;
+  }
   private UndoManager getUndoManager() {
     return getEditorPane().getUndoManager();
+  }
   /**
    * Forwards the request to the editor pane.
+   *
    * @param <T> The type of event listener to add.
    * @param <U> The type of consumer to add.
    * @param event The event that should trigger updates to the listener.
    * @param consumer The listener to receive update events.
    */
   public <T extends Event, U extends T> void addEventListener(
     final EventPattern<? super T, ? extends U> event,
     final Consumer<? super U> consumer ) {
     getEditorPane().addEventListener( event, consumer );
+  }
   /**
    * Forwards to the editor pane's listeners for keyboard events.
+   *
    * @param map The new input map to replace the existing keyboard listener.
    */
   public void addEventListener( final InputMap<InputEvent> map ) {
     getEditorPane().addEventListener( map );
+  }
   /**
    * Forwards to the editor pane's listeners for keyboard events.
+   *
    * @param map The existing input map to remove from the keyboard listeners.
    */
   public void removeEventListener( final InputMap<InputEvent> map ) {
     getEditorPane().removeEventListener( map );
+  }
   /**
    * 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 );
+  }
   /**
    * Forwards the request to the editor pane.
+   *
    * @return The text to process.
    */
   public String getEditorText() {
     return getEditorPane().getText();
+  }
   /**
    * Returns the editor pane, or creates one if it doesn't yet exist.
+   *
    * @return The editor pane, never null.
    */
   public EditorPane getEditorPane() {
     if( this.editorPane == null ) {
       this.editorPane = new MarkdownEditorPane();
+    }
     return this.editorPane;
+  }
   private Notifier getNotifyService() {
     return this.alertService;
+  }
   private Charset getEncoding() {
 import static java.nio.charset.StandardCharsets.UTF_8;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import static java.util.Locale.ENGLISH;
 import java.util.function.Consumer;
 import javafx.application.Platform;
 import javafx.beans.binding.Bindings;
 import javafx.beans.property.BooleanProperty;
 import javafx.beans.property.ReadOnlyBooleanProperty;
 import javafx.beans.property.ReadOnlyBooleanWrapper;
 import javafx.beans.property.SimpleBooleanProperty;
 import javafx.beans.value.ChangeListener;
 import javafx.beans.value.ObservableValue;
 import javafx.event.Event;
 import javafx.scene.Node;
 import javafx.scene.Scene;
 import javafx.scene.control.Tab;
 import javafx.scene.control.Tooltip;
 import javafx.scene.input.InputEvent;
 import javafx.scene.text.Text;
 import javafx.stage.Window;
 import org.fxmisc.richtext.StyleClassedTextArea;
 import static org.fxmisc.richtext.model.TwoDimensional.Bias.Forward;
 import org.fxmisc.richtext.model.TwoDimensional.Position;
 import org.fxmisc.undo.UndoManager;
 import org.fxmisc.wellbehaved.event.EventPattern;
 import org.fxmisc.wellbehaved.event.InputMap;
 import org.mozilla.universalchardet.UniversalDetector;
 /**
  * Editor for a single file.
+ *
  * @author Karl Tauber and White Magic Software, Ltd.
  */
 public final class FileEditorTab extends Tab {
   private final Notifier alertService = Services.load( Notifier.class );
   private EditorPane editorPane;
   /**
    * Character encoding used by the file (or default encoding if none found).
    */
   private Charset encoding;
   private final ReadOnlyBooleanWrapper modified = new ReadOnlyBooleanWrapper();
   private final BooleanProperty canUndo = new SimpleBooleanProperty();
   private final BooleanProperty canRedo = new SimpleBooleanProperty();
   private Path path;
   FileEditorTab( final Path path ) {
     setPath( path );
     this.modified.addListener( (observable, oldPath, newPath) -> updateTab() );
     setOnSelectionChanged( e -> {
       if( isSelected() ) {
         Platform.runLater( () -> 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() {
     final Path filePath = getPath();
     return (filePath == null)
       ? Messages.get( "FileEditor.untitled" )
       : filePath.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();
     // Clear undo history after first load.
     undoManager.forgetHistory();
     // Bind the editor undo manager to the properties.
     modified.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, 0 );
+    }
     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 ? false : filePath.equals( check );
+  }
   /**
    * Reads the entire file contents from the path associated with this tab.
    */
   private void load() {
     final Path filePath = getPath();
     if( filePath != null ) {
       try {
         getEditorPane().setText( asString( Files.readAllBytes( filePath ) ) );
       } catch( final Exception ex ) {
         getNotifyService().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 {
       Files.write( getPath(), asBytes( getEditorPane().getText() ) );
       getEditorPane().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
    */
   private boolean alert(
     final String titleKey, final String messageKey, final Exception e ) {
     final Notifier service = getNotifyService();
     final Path filePath = getPath();
     final Notification message = service.createNotification(
       Messages.get( titleKey ),
       Messages.get( messageKey ),
       filePath == null ? "" : filePath,
       e.getMessage()
     );
     try {
       service.createError( getWindow(), message ).showAndWait();
     } catch( final Exception ex ) {
       getNotifyService().notify( ex );
+    }
     return false;
+  }
   private Window getWindow() {
     final Scene scene = getEditorPane().getScene();
     if( scene == null ) {
       throw new UnsupportedOperationException( "" );
+    }
     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() );
+  }
   public Path getPath() {
     return this.path;
+  }
   public void setPath( final Path path ) {
     this.path = path;
     updateTab();
+  }
   /**
    * Answers whether this tab has an initialized path reference.
+   *
    * @return false This tab has no path.
    */
   public boolean isFileOpen() {
     return this.path != null;
+  }
   public boolean isModified() {
     return this.modified.get();
+  }
   ReadOnlyBooleanProperty modifiedProperty() {
     return this.modified.getReadOnlyProperty();
+  }
   BooleanProperty canUndoProperty() {
     return this.canUndo;
+  }
   BooleanProperty canRedoProperty() {
     return this.canRedo;
+  }
   private UndoManager getUndoManager() {
     return getEditorPane().getUndoManager();
+  }
   /**
    * Forwards the request to the editor pane.
+   *
    * @param <T> The type of event listener to add.
    * @param <U> The type of consumer to add.
    * @param event The event that should trigger updates to the listener.
    * @param consumer The listener to receive update events.
    */
   public <T extends Event, U extends T> void addEventListener(
     final EventPattern<? super T, ? extends U> event,
     final Consumer<? super U> consumer ) {
     getEditorPane().addEventListener( event, consumer );
+  }
   /**
    * Forwards to the editor pane's listeners for keyboard events.
+   *
    * @param map The new input map to replace the existing keyboard listener.
    */
   public void addEventListener( final InputMap<InputEvent> map ) {
     getEditorPane().addEventListener( map );
+  }
   /**
    * Forwards to the editor pane's listeners for keyboard events.
+   *
    * @param map The existing input map to remove from the keyboard listeners.
    */
   public void removeEventListener( final InputMap<InputEvent> map ) {
     getEditorPane().removeEventListener( map );
+  }
   /**
    * 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 );
+  }
   /**
    * Forwards the request to the editor pane.
+   *
    * @return The text to process.
    */
   public String getEditorText() {
     return getEditorPane().getText();
+  }
   /**
    * Returns the editor pane, or creates one if it doesn't yet exist.
+   *
    * @return The editor pane, never null.
    */
   public synchronized EditorPane getEditorPane() {
     if( this.editorPane == null ) {
       this.editorPane = new MarkdownEditorPane();
+    }
     return this.editorPane;
+  }
   private Notifier getNotifyService() {
     return this.alertService;
+  }
   /**
    * Returns the encoding for the file, defaulting to UTF-8 if it hasn't been
    * determined.
+   *
    * @return The file encoding or UTF-8 if unknown.
    */
   private Charset getEncoding() {
     if( this.encoding == null ) {
       this.encoding = UTF_8;
+    }
     return this.encoding;
+  }

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

 import org.fxmisc.wellbehaved.event.EventPattern;
 import org.fxmisc.wellbehaved.event.InputMap;
 import static com.scrivenvar.Messages.get;
 import static com.scrivenvar.Messages.get;
 import static com.scrivenvar.Messages.get;
 import static com.scrivenvar.Messages.get;
 import static com.scrivenvar.Messages.get;
 import static com.scrivenvar.Messages.get;
 import static com.scrivenvar.Messages.get;
 /**
  * Tab pane for file editors.
+ *
  * @author Karl Tauber and White Magic Software, Ltd.
  */
 public final class FileEditorTabPane extends TabPane {
   private final static String FILTER_EXTENSION_TITLES = "Dialog.file.choose.filter";
   private final Options options = Services.load( Options.class );
   private final Settings settings = Services.load( Settings.class );
   private final Notifier notifyService = Services.load(Notifier.class );
   private final ReadOnlyObjectWrapper<Path> openDefinition = new ReadOnlyObjectWrapper<>();
   private final ReadOnlyObjectWrapper<FileEditorTab> activeFileEditor = new ReadOnlyObjectWrapper<>();
   private final ReadOnlyBooleanWrapper anyFileEditorModified = new ReadOnlyBooleanWrapper();
   /**
    * Constructs a new file editor tab pane.
    */
   public FileEditorTabPane() {
     final ObservableList<Tab> tabs = getTabs();
     setFocusTraversable( false );
     setTabClosingPolicy( TabClosingPolicy.ALL_TABS );
     addTabSelectionListener(
       (ObservableValue<? extends Tab> tabPane,
         final Tab oldTab, final Tab newTab) -> {
         if( newTab != null ) {
           activeFileEditor.set( (FileEditorTab)newTab );
+        }
+      }
     );
     final ChangeListener<Boolean> modifiedListener = (observable, oldValue, newValue) -> {
       for( final Tab tab : tabs ) {
         if( ((FileEditorTab)tab).isModified() ) {
           this.anyFileEditorModified.set( true );
           break;
+        }
+      }
     };
     tabs.addListener(
       (ListChangeListener<Tab>)change -> {
         while( change.next() ) {
           if( change.wasAdded() ) {
             change.getAddedSubList().stream().forEach( (tab) -> {
               ((FileEditorTab)tab).modifiedProperty().addListener( modifiedListener );
             } );
           } else if( change.wasRemoved() ) {
             change.getRemoved().stream().forEach( (tab) -> {
               ((FileEditorTab)tab).modifiedProperty().removeListener( modifiedListener );
             } );
+          }
+        }
         // Changes in the tabs may also change anyFileEditorModified property
         // (e.g. closed modified file)
         modifiedListener.changed( null, null, null );
+      }
     );
+  }
   /**
    * Delegates to the active file editor.
+   *
    * @param <T> Event type.
    * @param <U> Consumer type.
    * @param event Event to pass to the editor.
    * @param consumer Consumer to pass to the editor.
    */
   public <T extends Event, U extends T> void addEventListener(
     final EventPattern<? super T, ? extends U> event,
     final Consumer<? super U> consumer ) {
     getActiveFileEditor().addEventListener( event, consumer );
+  }
   /**
    * Delegates to the active file editor pane, and, ultimately, to its text
    * area.
+   *
    * @param map The map of methods to events.
    */
   public void addEventListener( final InputMap<InputEvent> map ) {
     getActiveFileEditor().addEventListener( map );
+  }
   /**
    * Remove a keyboard event listener from the active file editor.
+   *
    * @param map The keyboard events to remove.
    */
   public void removeEventListener( final InputMap<InputEvent> map ) {
     getActiveFileEditor().removeEventListener( map );
+  }
   /**
    * Allows observers to be notified when the current file editor tab changes.
+   *
    * @param listener The listener to notify of tab change events.
    */
   public void addTabSelectionListener( final ChangeListener<Tab> listener ) {
     // Observe the tab so that when a new tab is opened or selected,
     // 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();
+  }
   public FileEditorTab getActiveFileEditor() {
     return this.activeFileEditor.get();
+  }
   public ReadOnlyObjectProperty<FileEditorTab> activeFileEditorProperty() {
     return this.activeFileEditor.getReadOnlyProperty();
+  }
   ReadOnlyBooleanProperty anyFileEditorModifiedProperty() {
     return this.anyFileEditorModified.getReadOnlyProperty();
+  }
   private FileEditorTab createFileEditor( final Path path ) {
     final FileEditorTab tab = new FileEditorTab( path );
     tab.setOnCloseRequest( e -> {
       if( !canCloseEditor( tab ) ) {
         e.consume();
+      }
     } );
     return tab;
+  }
   /**
    * Called when the user selects New from the File menu.
+   *
    * @return The newly added tab.
    */
   void newEditor() {
     final FileEditorTab tab = createFileEditor( null );
     getTabs().add( tab );
     getSelectionModel().select( tab );
+  }
   void openFileDialog() {
     final String title = get( "Dialog.file.choose.open.title" );
     final FileChooser dialog = createFileChooser( title );
     final List<File> files = dialog.showOpenMultipleDialog( getWindow() );
     if( files != null ) {
       openFiles( files );
+    }
+  }
   /**
    * Opens the files into new editors, unless one of those files was a
    * definition file. The definition file is loaded into the definition pane,
    * but only the first one selected (multiple definition files will result in a
    * warning).
+   *
    * @param files The list of non-definition files that the were requested to
    * open.
+   *
    * @return A list of files that can be opened in text editors.
    */
   private void openFiles( final List<File> files ) {
     final FileTypePredicate predicate
       = new FileTypePredicate( createExtensionFilter( DEFINITION ).getExtensions() );
     // The user might have opened multiple definitions files. These will
     // be discarded from the text editable files.
     final List<File> definitions
       = files.stream().filter( predicate ).collect( Collectors.toList() );
     // Create a modifiable list to remove any definition files that were
     // opened.
     final List<File> editors = new ArrayList<>( files );
     if( editors.size() > 0 ) {
       saveLastDirectory( editors.get( 0 ) );
+    }
     editors.removeAll( definitions );
     // Open editor-friendly files (e.g,. Markdown, XML) in new tabs.
     if( editors.size() > 0 ) {
       openEditors( editors, 0 );
+    }
     if( definitions.size() > 0 ) {
       openDefinition( definitions.get( 0 ) );
+    }
+  }
   private void openEditors( final List<File> files, final int activeIndex ) {
     final int fileTally = files.size();
     final List<Tab> tabs = getTabs();
     // Close single unmodified "Untitled" tab.
     if( tabs.size() == 1 ) {
       final FileEditorTab fileEditor = (FileEditorTab)(tabs.get( 0 ));
       if( fileEditor.getPath() == null && !fileEditor.isModified() ) {
         closeEditor( fileEditor, false );
+      }
+    }
     for( int i = 0; i < fileTally; i++ ) {
       final Path path = files.get( i ).toPath();
       FileEditorTab fileEditorTab = findEditor( path );
       // Only open new files.
       if( fileEditorTab == null ) {
         fileEditorTab = createFileEditor( path );
         getTabs().add( fileEditorTab );
+      }
       // Select the first file in the list.
       if( i == activeIndex ) {
         getSelectionModel().select( fileEditorTab );
+      }
+    }
+  }
   /**
    * Returns a property that changes when a new definition file is opened.
+   *
    * @return The path to a definition file that was opened.
    */
   public ReadOnlyObjectProperty<Path> onOpenDefinitionFileProperty() {
     return getOnOpenDefinitionFile().getReadOnlyProperty();
+  }
   private ReadOnlyObjectWrapper<Path> getOnOpenDefinitionFile() {
     return this.openDefinition;
+  }
   /**
    * Called when the user has opened a definition file (using the file open
    * dialog box). This will replace the current set of definitions for the
    * active tab.
+   *
    * @param definition The file to open.
    */
   private void openDefinition( final File definition ) {
     // TODO: Prevent reading this file twice when a new text document is opened.
     // (might be a matter of checking the value first).
     getOnOpenDefinitionFile().set( definition.toPath() );
+  }
   boolean saveEditor( final FileEditorTab fileEditor ) {
     if( fileEditor == null || !fileEditor.isModified() ) {
       return true;
+    }
     if( fileEditor.getPath() == null ) {
       getSelectionModel().select( fileEditor );
       final FileChooser fileChooser = createFileChooser( Messages.get( "Dialog.file.choose.save.title" ) );
       final File file = fileChooser.showSaveDialog( getWindow() );
       if( file == null ) {
         return false;
+      }
       saveLastDirectory( file );
       fileEditor.setPath( file.toPath() );
+    }
     return fileEditor.save();
+  }
   boolean saveAllEditors() {
     boolean success = true;
     for( FileEditorTab fileEditor : getAllEditors() ) {
       if( !saveEditor( fileEditor ) ) {
         success = false;
+      }
+    }
     return success;
+  }
   /**
    * Answers whether the file has had modifications. '
+   *
    * @param tab THe tab to check for modifications.
+   *
    * @return false The file is unmodified.
    */
   boolean canCloseEditor( final FileEditorTab tab ) {
     if( !tab.isModified() ) {
       return true;
+    }
     final Notification message = getNotifyService().createNotification(
       Messages.get( "Alert.file.close.title" ),
       Messages.get( "Alert.file.close.text" ),
       tab.getText()
     );
     final Alert alert = getNotifyService().createConfirmation(
       getWindow(), message );
     final ButtonType response = alert.showAndWait().get();
     return response == YES ? saveEditor( tab ) : response == NO;
+  }
   private Notifier getNotifyService() {
     return this.notifyService;
+  }
   boolean closeEditor( FileEditorTab fileEditor, boolean save ) {
     if( fileEditor == null ) {
       return true;
+    }
     final Tab tab = fileEditor;
     if( save ) {
       Event event = new Event( tab, tab, Tab.TAB_CLOSE_REQUEST_EVENT );
       Event.fireEvent( tab, event );
       if( event.isConsumed() ) {
         return false;
+      }
+    }
     getTabs().remove( tab );
     if( tab.getOnClosed() != null ) {
       Event.fireEvent( tab, new Event( Tab.CLOSED_EVENT ) );
+    }
     return true;
+  }
   boolean closeAllEditors() {
     final FileEditorTab[] allEditors = getAllEditors();
     final FileEditorTab activeEditor = getActiveFileEditor();
     // try to save active tab first because in case the user decides to cancel,
     // then it stays active
     if( activeEditor != null && !canCloseEditor( activeEditor ) ) {
       return false;
+    }
     // This should be called any time a tab changes.
     persistPreferences();
     // save modified tabs
     for( int i = 0; i < allEditors.length; i++ ) {
       final FileEditorTab fileEditor = allEditors[ i ];
       if( fileEditor == activeEditor ) {
         continue;
+      }
       if( fileEditor.isModified() ) {
         // activate the modified tab to make its modified content visible to the user
         getSelectionModel().select( i );
         if( !canCloseEditor( fileEditor ) ) {
           return false;
+        }
+      }
+    }
     // Close all tabs.
     for( final FileEditorTab fileEditor : allEditors ) {
       if( !closeEditor( fileEditor, false ) ) {
         return false;
+      }
+    }
     return getTabs().isEmpty();
+  }
   private FileEditorTab[] getAllEditors() {
     final ObservableList<Tab> tabs = getTabs();
     final int length = tabs.size();
     final FileEditorTab[] allEditors = new FileEditorTab[ length ];
     for( int i = 0; i < length; i++ ) {
       allEditors[ i ] = (FileEditorTab)tabs.get( i );
+    }
     return allEditors;
+  }
   /**
    * Returns the file editor tab that has the given path.
+   *
    * @return null No file editor tab for the given path was found.
    */
   private FileEditorTab findEditor( final Path path ) {
     for( final Tab tab : getTabs() ) {
       final FileEditorTab fileEditor = (FileEditorTab)tab;
       if( fileEditor.isPath( path ) ) {
         return fileEditor;
+      }
+    }
     return null;
+  }
   private FileChooser createFileChooser( String title ) {
     final FileChooser fileChooser = new FileChooser();
     fileChooser.setTitle( title );
     fileChooser.getExtensionFilters().addAll(
       createExtensionFilters() );
     final String lastDirectory = getPreferences().get( "lastDirectory", null );
     File file = new File( (lastDirectory != null) ? lastDirectory : "." );
     if( !file.isDirectory() ) {
       file = new File( "." );
+    }
     fileChooser.setInitialDirectory( file );
     return fileChooser;
+  }
   private List<ExtensionFilter> createExtensionFilters() {
     final List<ExtensionFilter> list = new ArrayList<>();
     // TODO: Return a list of all properties that match the filter prefix.
     // This will allow dynamic filters to be added and removed just by
     // updating the properties file.
     list.add( createExtensionFilter( MARKDOWN ) );
     list.add( createExtensionFilter( DEFINITION ) );
     list.add( createExtensionFilter( XML ) );
     list.add( createExtensionFilter( ALL ) );
     return list;
+  }
   /**
    * Returns a filter for file name extensions recognized by the application
    * that can be opened by the user.
+   *
    * @param filetype Used to find the globbing pattern for extensions.
+   *
    * @return A filename filter suitable for use by a FileDialog instance.
    */
   private ExtensionFilter createExtensionFilter( final FileType filetype ) {
     final String tKey = String.format( "%s.title.%s", FILTER_EXTENSION_TITLES, filetype );
     final String eKey = String.format( "%s.%s", GLOB_PREFIX_FILE, filetype );
     return new ExtensionFilter( Messages.get( tKey ), getExtensions( eKey ) );
+  }
   private List<String> getExtensions( final String key ) {
     return getSettings().getStringSettingList( key );
+  }
   private void saveLastDirectory( final File file ) {
     getPreferences().put( "lastDirectory", file.getParent() );
+  }
   public void restorePreferences() {
     int activeIndex = 0;
     final Preferences preferences = getPreferences();
     final String[] fileNames = Utils.getPrefsStrings( preferences, "file" );
     final String activeFileName = preferences.get( "activeFile", null );
     final ArrayList<File> files = new ArrayList<>( fileNames.length );
     for( final String fileName : fileNames ) {
       final File file = new File( fileName );
       if( file.exists() ) {
         files.add( file );
         if( fileName.equals( activeFileName ) ) {
           activeIndex = files.size() - 1;
+        }
+      }
+    }
     if( files.isEmpty() ) {
       newEditor();
     } else {
       openEditors( files, activeIndex );
+    }
+  }
   public void persistPreferences() {
     final ObservableList<Tab> allEditors = getTabs();
     final List<String> fileNames = new ArrayList<>( allEditors.size() );
     for( final Tab tab : allEditors ) {
       final FileEditorTab fileEditor = (FileEditorTab)tab;
       final Path filePath = fileEditor.getPath();
       if( filePath != null ) {
         fileNames.add( filePath.toString() );
+      }
+    }
     final Preferences preferences = getPreferences();
     Utils.putPrefsStrings( preferences, "file", fileNames.toArray( new String[ fileNames.size() ] ) );
     final FileEditorTab activeEditor = getActiveFileEditor();
     final Path filePath = activeEditor == null ? null : activeEditor.getPath();
     if( filePath == null ) {
       preferences.remove( "activeFile" );
     } else {
 /**
  * Tab pane for file editors.
+ *
  * @author Karl Tauber and White Magic Software, Ltd.
  */
 public final class FileEditorTabPane extends TabPane {
   private final static String FILTER_EXTENSION_TITLES = "Dialog.file.choose.filter";
   private final Options options = Services.load( Options.class );
   private final Settings settings = Services.load( Settings.class );
   private final Notifier notifyService = Services.load( Notifier.class );
   private final ReadOnlyObjectWrapper<Path> openDefinition = new ReadOnlyObjectWrapper<>();
   private final ReadOnlyObjectWrapper<FileEditorTab> activeFileEditor = new ReadOnlyObjectWrapper<>();
   private final ReadOnlyBooleanWrapper anyFileEditorModified = new ReadOnlyBooleanWrapper();
   /**
    * Constructs a new file editor tab pane.
    */
   public FileEditorTabPane() {
     final ObservableList<Tab> tabs = getTabs();
     setFocusTraversable( false );
     setTabClosingPolicy( TabClosingPolicy.ALL_TABS );
     addTabSelectionListener(
       (ObservableValue<? extends Tab> tabPane,
         final Tab oldTab, final Tab newTab) -> {
         if( newTab != null ) {
           activeFileEditor.set( (FileEditorTab)newTab );
+        }
+      }
     );
     final ChangeListener<Boolean> modifiedListener = (observable, oldValue, newValue) -> {
       for( final Tab tab : tabs ) {
         if( ((FileEditorTab)tab).isModified() ) {
           this.anyFileEditorModified.set( true );
           break;
+        }
+      }
     };
     tabs.addListener(
       (ListChangeListener<Tab>)change -> {
         while( change.next() ) {
           if( change.wasAdded() ) {
             change.getAddedSubList().stream().forEach( (tab) -> {
               ((FileEditorTab)tab).modifiedProperty().addListener( modifiedListener );
             } );
+          }
           else if( change.wasRemoved() ) {
             change.getRemoved().stream().forEach( (tab) -> {
               ((FileEditorTab)tab).modifiedProperty().removeListener( modifiedListener );
             } );
+          }
+        }
         // Changes in the tabs may also change anyFileEditorModified property
         // (e.g. closed modified file)
         modifiedListener.changed( null, null, null );
+      }
     );
+  }
   /**
    * Delegates to the active file editor.
+   *
    * @param <T> Event type.
    * @param <U> Consumer type.
    * @param event Event to pass to the editor.
    * @param consumer Consumer to pass to the editor.
    */
   public <T extends Event, U extends T> void addEventListener(
     final EventPattern<? super T, ? extends U> event,
     final Consumer<? super U> consumer ) {
     getActiveFileEditor().addEventListener( event, consumer );
+  }
   /**
    * Delegates to the active file editor pane, and, ultimately, to its text
    * area.
+   *
    * @param map The map of methods to events.
    */
   public void addEventListener( final InputMap<InputEvent> map ) {
     getActiveFileEditor().addEventListener( map );
+  }
   /**
    * Remove a keyboard event listener from the active file editor.
+   *
    * @param map The keyboard events to remove.
    */
   public void removeEventListener( final InputMap<InputEvent> map ) {
     getActiveFileEditor().removeEventListener( map );
+  }
   /**
    * Allows observers to be notified when the current file editor tab changes.
+   *
    * @param listener The listener to notify of tab change events.
    */
   public void addTabSelectionListener( final ChangeListener<Tab> listener ) {
     // Observe the tab so that when a new tab is opened or selected,
     // 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();
+  }
   public FileEditorTab getActiveFileEditor() {
     return this.activeFileEditor.get();
+  }
   public ReadOnlyObjectProperty<FileEditorTab> activeFileEditorProperty() {
     return this.activeFileEditor.getReadOnlyProperty();
+  }
   ReadOnlyBooleanProperty anyFileEditorModifiedProperty() {
     return this.anyFileEditorModified.getReadOnlyProperty();
+  }
   private FileEditorTab createFileEditor( final Path path ) {
     final FileEditorTab tab = new FileEditorTab( path );
     tab.setOnCloseRequest( e -> {
       if( !canCloseEditor( tab ) ) {
         e.consume();
+      }
     } );
     return tab;
+  }
   /**
    * Called when the user selects New from the File menu.
+   *
    * @return The newly added tab.
    */
   void newEditor() {
     final FileEditorTab tab = createFileEditor( null );
     getTabs().add( tab );
     getSelectionModel().select( tab );
+  }
   void openFileDialog() {
     final String title = get( "Dialog.file.choose.open.title" );
     final FileChooser dialog = createFileChooser( title );
     final List<File> files = dialog.showOpenMultipleDialog( getWindow() );
     if( files != null ) {
       openFiles( files );
+    }
+  }
   /**
    * Opens the files into new editors, unless one of those files was a
    * definition file. The definition file is loaded into the definition pane,
    * but only the first one selected (multiple definition files will result in a
    * warning).
+   *
    * @param files The list of non-definition files that the were requested to
    * open.
+   *
    * @return A list of files that can be opened in text editors.
    */
   private void openFiles( final List<File> files ) {
     final FileTypePredicate predicate
       = new FileTypePredicate( createExtensionFilter( DEFINITION ).getExtensions() );
     // The user might have opened multiple definitions files. These will
     // be discarded from the text editable files.
     final List<File> definitions
       = files.stream().filter( predicate ).collect( Collectors.toList() );
     // Create a modifiable list to remove any definition files that were
     // opened.
     final List<File> editors = new ArrayList<>( files );
     if( editors.size() > 0 ) {
       saveLastDirectory( editors.get( 0 ) );
+    }
     editors.removeAll( definitions );
     // Open editor-friendly files (e.g,. Markdown, XML) in new tabs.
     if( editors.size() > 0 ) {
       openEditors( editors, 0 );
+    }
     if( definitions.size() > 0 ) {
       openDefinition( definitions.get( 0 ) );
+    }
+  }
   private void openEditors( final List<File> files, final int activeIndex ) {
     final int fileTally = files.size();
     final List<Tab> tabs = getTabs();
     // Close single unmodified "Untitled" tab.
     if( tabs.size() == 1 ) {
       final FileEditorTab fileEditor = (FileEditorTab)(tabs.get( 0 ));
       if( fileEditor.getPath() == null && !fileEditor.isModified() ) {
         closeEditor( fileEditor, false );
+      }
+    }
     for( int i = 0; i < fileTally; i++ ) {
       final Path path = files.get( i ).toPath();
       FileEditorTab fileEditorTab = findEditor( path );
       // Only open new files.
       if( fileEditorTab == null ) {
         fileEditorTab = createFileEditor( path );
         getTabs().add( fileEditorTab );
+      }
       // Select the first file in the list.
       if( i == activeIndex ) {
         getSelectionModel().select( fileEditorTab );
+      }
+    }
+  }
   /**
    * Returns a property that changes when a new definition file is opened.
+   *
    * @return The path to a definition file that was opened.
    */
   public ReadOnlyObjectProperty<Path> onOpenDefinitionFileProperty() {
     return getOnOpenDefinitionFile().getReadOnlyProperty();
+  }
   private ReadOnlyObjectWrapper<Path> getOnOpenDefinitionFile() {
     return this.openDefinition;
+  }
   /**
    * Called when the user has opened a definition file (using the file open
    * dialog box). This will replace the current set of definitions for the
    * active tab.
+   *
    * @param definition The file to open.
    */
   private void openDefinition( final File definition ) {
     // TODO: Prevent reading this file twice when a new text document is opened.
     // (might be a matter of checking the value first).
     getOnOpenDefinitionFile().set( definition.toPath() );
+  }
   boolean saveEditor( final FileEditorTab tab ) {
     if( tab == null || !tab.isModified() ) {
       return true;
+    }
     return tab.getPath() == null ? saveEditorAs( tab ) : tab.save();
+  }
   boolean saveEditorAs( final FileEditorTab tab ) {
     if( tab == null ) {
       return true;
+    }
     getSelectionModel().select( tab );
     final FileChooser fileChooser = createFileChooser( get( "Dialog.file.choose.save.title" ) );
     final File file = fileChooser.showSaveDialog( getWindow() );
     if( file == null ) {
       return false;
+    }
     saveLastDirectory( file );
     tab.setPath( file.toPath() );
     return tab.save();
+  }
   boolean saveAllEditors() {
     boolean success = true;
     for( FileEditorTab fileEditor : getAllEditors() ) {
       if( !saveEditor( fileEditor ) ) {
         success = false;
+      }
+    }
     return success;
+  }
   /**
    * Answers whether the file has had modifications. '
+   *
    * @param tab THe tab to check for modifications.
+   *
    * @return false The file is unmodified.
    */
   boolean canCloseEditor( final FileEditorTab tab ) {
     if( !tab.isModified() ) {
       return true;
+    }
     final Notification message = getNotifyService().createNotification(
       Messages.get( "Alert.file.close.title" ),
       Messages.get( "Alert.file.close.text" ),
       tab.getText()
     );
     final Alert alert = getNotifyService().createConfirmation(
       getWindow(), message );
     final ButtonType response = alert.showAndWait().get();
     return response == YES ? saveEditor( tab ) : response == NO;
+  }
   private Notifier getNotifyService() {
     return this.notifyService;
+  }
   boolean closeEditor( FileEditorTab fileEditor, boolean save ) {
     if( fileEditor == null ) {
       return true;
+    }
     final Tab tab = fileEditor;
     if( save ) {
       Event event = new Event( tab, tab, Tab.TAB_CLOSE_REQUEST_EVENT );
       Event.fireEvent( tab, event );
       if( event.isConsumed() ) {
         return false;
+      }
+    }
     getTabs().remove( tab );
     if( tab.getOnClosed() != null ) {
       Event.fireEvent( tab, new Event( Tab.CLOSED_EVENT ) );
+    }
     return true;
+  }
   boolean closeAllEditors() {
     final FileEditorTab[] allEditors = getAllEditors();
     final FileEditorTab activeEditor = getActiveFileEditor();
     // try to save active tab first because in case the user decides to cancel,
     // then it stays active
     if( activeEditor != null && !canCloseEditor( activeEditor ) ) {
       return false;
+    }
     // This should be called any time a tab changes.
     persistPreferences();
     // save modified tabs
     for( int i = 0; i < allEditors.length; i++ ) {
       final FileEditorTab fileEditor = allEditors[ i ];
       if( fileEditor == activeEditor ) {
         continue;
+      }
       if( fileEditor.isModified() ) {
         // activate the modified tab to make its modified content visible to the user
         getSelectionModel().select( i );
         if( !canCloseEditor( fileEditor ) ) {
           return false;
+        }
+      }
+    }
     // Close all tabs.
     for( final FileEditorTab fileEditor : allEditors ) {
       if( !closeEditor( fileEditor, false ) ) {
         return false;
+      }
+    }
     return getTabs().isEmpty();
+  }
   private FileEditorTab[] getAllEditors() {
     final ObservableList<Tab> tabs = getTabs();
     final int length = tabs.size();
     final FileEditorTab[] allEditors = new FileEditorTab[ length ];
     for( int i = 0; i < length; i++ ) {
       allEditors[ i ] = (FileEditorTab)tabs.get( i );
+    }
     return allEditors;
+  }
   /**
    * Returns the file editor tab that has the given path.
+   *
    * @return null No file editor tab for the given path was found.
    */
   private FileEditorTab findEditor( final Path path ) {
     for( final Tab tab : getTabs() ) {
       final FileEditorTab fileEditor = (FileEditorTab)tab;
       if( fileEditor.isPath( path ) ) {
         return fileEditor;
+      }
+    }
     return null;
+  }
   private FileChooser createFileChooser( String title ) {
     final FileChooser fileChooser = new FileChooser();
     fileChooser.setTitle( title );
     fileChooser.getExtensionFilters().addAll(
       createExtensionFilters() );
     final String lastDirectory = getPreferences().get( "lastDirectory", null );
     File file = new File( (lastDirectory != null) ? lastDirectory : "." );
     if( !file.isDirectory() ) {
       file = new File( "." );
+    }
     fileChooser.setInitialDirectory( file );
     return fileChooser;
+  }
   private List<ExtensionFilter> createExtensionFilters() {
     final List<ExtensionFilter> list = new ArrayList<>();
     // TODO: Return a list of all properties that match the filter prefix.
     // This will allow dynamic filters to be added and removed just by
     // updating the properties file.
     list.add( createExtensionFilter( MARKDOWN ) );
     list.add( createExtensionFilter( DEFINITION ) );
     list.add( createExtensionFilter( XML ) );
     list.add( createExtensionFilter( ALL ) );
     return list;
+  }
   /**
    * Returns a filter for file name extensions recognized by the application
    * that can be opened by the user.
+   *
    * @param filetype Used to find the globbing pattern for extensions.
+   *
    * @return A filename filter suitable for use by a FileDialog instance.
    */
   private ExtensionFilter createExtensionFilter( final FileType filetype ) {
     final String tKey = String.format( "%s.title.%s", FILTER_EXTENSION_TITLES, filetype );
     final String eKey = String.format( "%s.%s", GLOB_PREFIX_FILE, filetype );
     return new ExtensionFilter( Messages.get( tKey ), getExtensions( eKey ) );
+  }
   private List<String> getExtensions( final String key ) {
     return getSettings().getStringSettingList( key );
+  }
   private void saveLastDirectory( final File file ) {
     getPreferences().put( "lastDirectory", file.getParent() );
+  }
   public void restorePreferences() {
     int activeIndex = 0;
     final Preferences preferences = getPreferences();
     final String[] fileNames = Utils.getPrefsStrings( preferences, "file" );
     final String activeFileName = preferences.get( "activeFile", null );
     final ArrayList<File> files = new ArrayList<>( fileNames.length );
     for( final String fileName : fileNames ) {
       final File file = new File( fileName );
       if( file.exists() ) {
         files.add( file );
         if( fileName.equals( activeFileName ) ) {
           activeIndex = files.size() - 1;
+        }
+      }
+    }
     if( files.isEmpty() ) {
       newEditor();
+    }
     else {
       openEditors( files, activeIndex );
+    }
+  }
   public void persistPreferences() {
     final ObservableList<Tab> allEditors = getTabs();
     final List<String> fileNames = new ArrayList<>( allEditors.size() );
     for( final Tab tab : allEditors ) {
       final FileEditorTab fileEditor = (FileEditorTab)tab;
       final Path filePath = fileEditor.getPath();
       if( filePath != null ) {
         fileNames.add( filePath.toString() );
+      }
+    }
     final Preferences preferences = getPreferences();
     Utils.putPrefsStrings( preferences, "file", fileNames.toArray( new String[ fileNames.size() ] ) );
     final FileEditorTab activeEditor = getActiveFileEditor();
     final Path filePath = activeEditor == null ? null : activeEditor.getPath();
     if( filePath == null ) {
       preferences.remove( "activeFile" );
+    }
     else {
       preferences.put( "activeFile", filePath.toString() );
+    }

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

   DEFINITION( "definition" ),
   XML( "xml" ),
   CSV( "csv" ),
   JSON( "json" ),
   TOML( "toml" ),

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

+  }
   private void fileSaveAll() {
     getFileEditorPane().saveAllEditors();
+  }
   private void fileExit() {
     final Window window = getWindow();
     fireEvent( window, new WindowEvent( window, WINDOW_CLOSE_REQUEST ) );
+  }
   //---- Tools actions
   private void toolsScript() {
     final String script = getStartupScript();
     final RScriptDialog dialog = new RScriptDialog(
       getWindow(), "Dialog.rScript.title", script );
     final Optional<String> result = dialog.showAndWait();
     result.ifPresent( (String s) -> {
       putStartupScript( s );
     } );
+  }
   /**
    * Gets the R startup script from the user preferences.
    */
   private String getStartupScript() {
     return getPreferences().get( PERSIST_R_STARTUP, "" );
+  }
   /**
    * Puts an R startup script into the user preferences.
    */
   private void putStartupScript( final String s ) {
     try {
       getPreferences().put( PERSIST_R_STARTUP, s );
     } catch( final Exception ex ) {
       getNotifier().notify( ex );
+    }
+  }
   //---- Help actions -------------------------------------------------------
   private void helpAbout() {
     Alert alert = new Alert( AlertType.INFORMATION );
     alert.setTitle( get( "Dialog.about.title" ) );
     alert.setHeaderText( get( "Dialog.about.header" ) );
     alert.setContentText( get( "Dialog.about.content" ) );
     alert.setGraphic( new ImageView( new Image( FILE_LOGO_32 ) ) );
     alert.initOwner( getWindow() );
     alert.showAndWait();
+  }
   //---- Convenience accessors ----------------------------------------------
   private float getFloat( final String key, final float defaultValue ) {
     return getPreferences().getFloat( key, defaultValue );
+  }
   private Preferences getPreferences() {
     return getOptions().getState();
+  }
   protected Scene getScene() {
     if( this.scene == null ) {
       this.scene = createScene();
+    }
     return this.scene;
+  }
   public Window getWindow() {
     return getScene().getWindow();
+  }
   private MarkdownEditorPane getActiveEditor() {
     final EditorPane pane = getActiveFileEditor().getEditorPane();
     return pane instanceof MarkdownEditorPane ? (MarkdownEditorPane)pane : null;
+  }
   private FileEditorTab getActiveFileEditor() {
     return getFileEditorPane().getActiveFileEditor();
+  }
   //---- Member accessors ---------------------------------------------------
   private void setProcessors( final Map<FileEditorTab, Processor<String>> map ) {
     this.processors = map;
+  }
   private Map<FileEditorTab, Processor<String>> getProcessors() {
     if( this.processors == null ) {
       setProcessors( new HashMap<>() );
+    }
     return this.processors;
+  }
   private FileEditorTabPane getFileEditorPane() {
     if( this.fileEditorPane == null ) {
       this.fileEditorPane = createFileEditorPane();
+    }
     return this.fileEditorPane;
+  }
   private HTMLPreviewPane getPreviewPane() {
     if( this.previewPane == null ) {
       this.previewPane = createPreviewPane();
+    }
     return this.previewPane;
+  }
   private void setDefinitionSource( final DefinitionSource definitionSource ) {
     this.definitionSource = definitionSource;
+  }
   private DefinitionSource getDefinitionSource() {
     if( this.definitionSource == null ) {
       this.definitionSource = new EmptyDefinitionSource();
+    }
     return this.definitionSource;
+  }
   private DefinitionPane getDefinitionPane() {
     if( this.definitionPane == null ) {
       this.definitionPane = createDefinitionPane();
+    }
     return this.definitionPane;
+  }
   private Options getOptions() {
     return this.options;
+  }
   private Snitch getSnitch() {
     return this.snitch;
+  }
   private Notifier getNotifier() {
     return this.notifier;
+  }
   public void setMenuBar( final MenuBar menuBar ) {
     this.menuBar = menuBar;
+  }
   public MenuBar getMenuBar() {
     return this.menuBar;
+  }
   private Text getLineNumberText() {
     if( this.lineNumberText == null ) {
       this.lineNumberText = createLineNumberText();
+    }
     return this.lineNumberText;
+  }
   private synchronized StatusBar getStatusBar() {
     if( this.statusBar == null ) {
       this.statusBar = createStatusBar();
+    }
     return this.statusBar;
+  }
   private TextField getFindTextField() {
     if( this.findTextField == null ) {
       this.findTextField = createFindTextField();
+    }
     return this.findTextField;
+  }
   //---- Member creators ----------------------------------------------------
   /**
    * Factory to create processors that are suited to different file types.
+   *
    * @param tab The tab that is subjected to processing.
+   *
    * @return A processor suited to the file type specified by the tab's path.
    */
   private Processor<String> createProcessor( final FileEditorTab tab ) {
     return createProcessorFactory().createProcessor( tab );
+  }
   private ProcessorFactory createProcessorFactory() {
     return new ProcessorFactory( getPreviewPane(), getResolvedMap() );
+  }
   private DefinitionSource createDefinitionSource( final String path ) {
     final DefinitionSource ds
       = createDefinitionFactory().createDefinitionSource( path );
     if( ds instanceof FileDefinitionSource ) {
       try {
         getSnitch().listen( ((FileDefinitionSource)ds).getPath() );
       } catch( final IOException ex ) {
         error( ex );
+      }
+    }
     return ds;
+  }
   private TextField createFindTextField() {
     return new TextField();
+  }
   /**
    * Create an editor pane to hold file editor tabs.
+   *
    * @return A new instance, never null.
    */
   private FileEditorTabPane createFileEditorPane() {
     return new FileEditorTabPane();
+  }
   private HTMLPreviewPane createPreviewPane() {
     return new HTMLPreviewPane();
+  }
   private DefinitionPane createDefinitionPane() {
     return new DefinitionPane( getTreeView() );
+  }
   private DefinitionFactory createDefinitionFactory() {
     return new DefinitionFactory();
+  }
   private StatusBar createStatusBar() {
     return new StatusBar();
+  }
   private Scene createScene() {
     final SplitPane splitPane = new SplitPane(
       getDefinitionPane().getNode(),
       getFileEditorPane().getNode(),
       getPreviewPane().getNode() );
     splitPane.setDividerPositions(
       getFloat( K_PANE_SPLIT_DEFINITION, .10f ),
       getFloat( K_PANE_SPLIT_EDITOR, .45f ),
       getFloat( K_PANE_SPLIT_PREVIEW, .45f ) );
     // See: http://broadlyapplicable.blogspot.ca/2015/03/javafx-capture-restorePreferences-splitpane.html
     final BorderPane borderPane = new BorderPane();
     borderPane.setPrefSize( 1024, 800 );
     borderPane.setTop( createMenuBar() );
     borderPane.setBottom( getStatusBar() );
     borderPane.setCenter( splitPane );
     final VBox box = new VBox();
     box.setAlignment( Pos.BASELINE_CENTER );
     box.getChildren().add( getLineNumberText() );
     getStatusBar().getRightItems().add( box );
     return new Scene( borderPane );
+  }
   private Text createLineNumberText() {
     return new Text( get( STATUS_BAR_LINE, 1, 1, 1 ) );
+  }
   private Node createMenuBar() {
     final BooleanBinding activeFileEditorIsNull = getFileEditorPane().activeFileEditorProperty().isNull();
     // File actions
     final Action fileNewAction = new Action( get( "Main.menu.file.new" ), "Shortcut+N", FILE_ALT, e -> fileNew() );
     final Action fileOpenAction = new Action( get( "Main.menu.file.open" ), "Shortcut+O", FOLDER_OPEN_ALT, e -> fileOpen() );
     final Action fileCloseAction = new Action( get( "Main.menu.file.close" ), "Shortcut+W", null, e -> fileClose(), activeFileEditorIsNull );
     final Action fileCloseAllAction = new Action( get( "Main.menu.file.close_all" ), null, null, e -> fileCloseAll(), activeFileEditorIsNull );
     final Action fileSaveAction = new Action( get( "Main.menu.file.save" ), "Shortcut+S", FLOPPY_ALT, e -> fileSave(),
       createActiveBooleanProperty( FileEditorTab::modifiedProperty ).not() );
     final Action fileSaveAllAction = new Action( get( "Main.menu.file.save_all" ), "Shortcut+Shift+S", null, e -> fileSaveAll(),
       Bindings.not( getFileEditorPane().anyFileEditorModifiedProperty() ) );
     final Action fileExitAction = new Action( get( "Main.menu.file.exit" ), null, null, e -> fileExit() );
     // Edit actions
     final Action editUndoAction = new Action( get( "Main.menu.edit.undo" ), "Shortcut+Z", UNDO,
       e -> getActiveEditor().undo(),
       createActiveBooleanProperty( FileEditorTab::canUndoProperty ).not() );
     final Action editRedoAction = new Action( get( "Main.menu.edit.redo" ), "Shortcut+Y", REPEAT,
       e -> getActiveEditor().redo(),
       createActiveBooleanProperty( FileEditorTab::canRedoProperty ).not() );
     final Action editFindAction = new Action( Messages.get( "Main.menu.edit.find" ), "Ctrl+F", SEARCH,
       e -> find(),
       activeFileEditorIsNull );
     final Action editReplaceAction = new Action( Messages.get( "Main.menu.edit.find.replace" ), "Shortcut+H", RETWEET,
       e -> getActiveEditor().replace(),
       activeFileEditorIsNull );
     final Action editFindNextAction = new Action( Messages.get( "Main.menu.edit.find.next" ), "F3", null,
       e -> findNext(),
       activeFileEditorIsNull );
     final Action editFindPreviousAction = new Action( Messages.get( "Main.menu.edit.find.previous" ), "Shift+F3", null,
       e -> getActiveEditor().findPrevious(),
       activeFileEditorIsNull );
     // Insert actions
     final Action insertBoldAction = new Action( get( "Main.menu.insert.bold" ), "Shortcut+B", BOLD,
       e -> getActiveEditor().surroundSelection( "**", "**" ),
       activeFileEditorIsNull );
     final Action insertItalicAction = new Action( get( "Main.menu.insert.italic" ), "Shortcut+I", ITALIC,
       e -> getActiveEditor().surroundSelection( "*", "*" ),
       activeFileEditorIsNull );
     final Action insertSuperscriptAction = new Action( get( "Main.menu.insert.superscript" ), "Shortcut+[", SUPERSCRIPT,
       e -> getActiveEditor().surroundSelection( "^", "^" ),
       activeFileEditorIsNull );
     final Action insertSubscriptAction = new Action( get( "Main.menu.insert.subscript" ), "Shortcut+]", SUBSCRIPT,
       e -> getActiveEditor().surroundSelection( "~", "~" ),
       activeFileEditorIsNull );
     final Action insertStrikethroughAction = new Action( get( "Main.menu.insert.strikethrough" ), "Shortcut+T", STRIKETHROUGH,
       e -> getActiveEditor().surroundSelection( "~~", "~~" ),
       activeFileEditorIsNull );
     final Action insertBlockquoteAction = new Action( get( "Main.menu.insert.blockquote" ), "Ctrl+Q", QUOTE_LEFT, // not Shortcut+Q because of conflict on Mac
       e -> getActiveEditor().surroundSelection( "\n\n> ", "" ),
       activeFileEditorIsNull );
     final Action insertCodeAction = new Action( get( "Main.menu.insert.code" ), "Shortcut+K", CODE,
       e -> getActiveEditor().surroundSelection( "`", "`" ),
       activeFileEditorIsNull );
     final Action insertFencedCodeBlockAction = new Action( get( "Main.menu.insert.fenced_code_block" ), "Shortcut+Shift+K", FILE_CODE_ALT,
       e -> getActiveEditor().surroundSelection( "\n\n```\n", "\n```\n\n", get( "Main.menu.insert.fenced_code_block.prompt" ) ),
       activeFileEditorIsNull );
     final Action insertLinkAction = new Action( get( "Main.menu.insert.link" ), "Shortcut+L", LINK,
       e -> getActiveEditor().insertLink(),
       activeFileEditorIsNull );
     final Action insertImageAction = new Action( get( "Main.menu.insert.image" ), "Shortcut+G", PICTURE_ALT,
       e -> getActiveEditor().insertImage(),
       activeFileEditorIsNull );
     final Action[] headers = new Action[ 6 ];
     // Insert header actions (H1 ... H6)
     for( int i = 1; i <= 6; i++ ) {
       final String hashes = new String( new char[ i ] ).replace( "\0", "#" );
       final String markup = String.format( "%n%n%s ", hashes );
       final String text = get( "Main.menu.insert.header_" + i );
       final String accelerator = "Shortcut+" + i;
       final String prompt = get( "Main.menu.insert.header_" + i + ".prompt" );
       headers[ i - 1 ] = new Action( text, accelerator, HEADER,
         e -> getActiveEditor().surroundSelection( markup, "", prompt ),
         activeFileEditorIsNull );
+    }
     final Action insertUnorderedListAction = new Action(
       get( "Main.menu.insert.unordered_list" ), "Shortcut+U", LIST_UL,
       e -> getActiveEditor().surroundSelection( "\n\n* ", "" ),
       activeFileEditorIsNull );
     final Action insertOrderedListAction = new Action(
       get( "Main.menu.insert.ordered_list" ), "Shortcut+Shift+O", LIST_OL,
       e -> getActiveEditor().surroundSelection( "\n\n1. ", "" ),
       activeFileEditorIsNull );
     final Action insertHorizontalRuleAction = new Action(
       get( "Main.menu.insert.horizontal_rule" ), "Shortcut+H", null,
       e -> getActiveEditor().surroundSelection( "\n\n---\n\n", "" ),
       activeFileEditorIsNull );
     // Tools actions
     final Action toolsScriptAction = new Action(
       get( "Main.menu.tools.script" ), null, null, e -> toolsScript() );
     // Help actions
     final Action helpAboutAction = new Action(
       get( "Main.menu.help.about" ), null, null, e -> helpAbout() );
     //---- MenuBar ----
     final Menu fileMenu = ActionUtils.createMenu( get( "Main.menu.file" ),
       fileNewAction,
       fileOpenAction,
       null,
       fileCloseAction,
       fileCloseAllAction,
       null,
       fileSaveAction,
   private void fileSaveAs() {
     final FileEditorTab editor = getActiveFileEditor();
     getFileEditorPane().saveEditorAs( editor );
     getProcessors().remove( editor );
     try {
       refreshSelectedTab( editor );
     } catch( final Exception ex ) {
       getNotifier().notify( ex );
+    }
+  }
   private void fileSaveAll() {
     getFileEditorPane().saveAllEditors();
+  }
   private void fileExit() {
     final Window window = getWindow();
     fireEvent( window, new WindowEvent( window, WINDOW_CLOSE_REQUEST ) );
+  }
   //---- Tools actions
   private void toolsScript() {
     final String script = getStartupScript();
     final RScriptDialog dialog = new RScriptDialog(
       getWindow(), "Dialog.rScript.title", script );
     final Optional<String> result = dialog.showAndWait();
     result.ifPresent( (String s) -> {
       putStartupScript( s );
     } );
+  }
   /**
    * Gets the R startup script from the user preferences.
    */
   private String getStartupScript() {
     return getPreferences().get( PERSIST_R_STARTUP, "" );
+  }
   /**
    * Puts an R startup script into the user preferences.
    */
   private void putStartupScript( final String s ) {
     try {
       getPreferences().put( PERSIST_R_STARTUP, s );
     } catch( final Exception ex ) {
       getNotifier().notify( ex );
+    }
+  }
   //---- Help actions -------------------------------------------------------
   private void helpAbout() {
     Alert alert = new Alert( AlertType.INFORMATION );
     alert.setTitle( get( "Dialog.about.title" ) );
     alert.setHeaderText( get( "Dialog.about.header" ) );
     alert.setContentText( get( "Dialog.about.content" ) );
     alert.setGraphic( new ImageView( new Image( FILE_LOGO_32 ) ) );
     alert.initOwner( getWindow() );
     alert.showAndWait();
+  }
   //---- Convenience accessors ----------------------------------------------
   private float getFloat( final String key, final float defaultValue ) {
     return getPreferences().getFloat( key, defaultValue );
+  }
   private Preferences getPreferences() {
     return getOptions().getState();
+  }
   protected Scene getScene() {
     if( this.scene == null ) {
       this.scene = createScene();
+    }
     return this.scene;
+  }
   public Window getWindow() {
     return getScene().getWindow();
+  }
   private MarkdownEditorPane getActiveEditor() {
     final EditorPane pane = getActiveFileEditor().getEditorPane();
     return pane instanceof MarkdownEditorPane ? (MarkdownEditorPane)pane : null;
+  }
   private FileEditorTab getActiveFileEditor() {
     return getFileEditorPane().getActiveFileEditor();
+  }
   //---- Member accessors ---------------------------------------------------
   private void setProcessors( final Map<FileEditorTab, Processor<String>> map ) {
     this.processors = map;
+  }
   private Map<FileEditorTab, Processor<String>> getProcessors() {
     if( this.processors == null ) {
       setProcessors( new HashMap<>() );
+    }
     return this.processors;
+  }
   private FileEditorTabPane getFileEditorPane() {
     if( this.fileEditorPane == null ) {
       this.fileEditorPane = createFileEditorPane();
+    }
     return this.fileEditorPane;
+  }
   private HTMLPreviewPane getPreviewPane() {
     if( this.previewPane == null ) {
       this.previewPane = createPreviewPane();
+    }
     return this.previewPane;
+  }
   private void setDefinitionSource( final DefinitionSource definitionSource ) {
     this.definitionSource = definitionSource;
+  }
   private DefinitionSource getDefinitionSource() {
     if( this.definitionSource == null ) {
       this.definitionSource = new EmptyDefinitionSource();
+    }
     return this.definitionSource;
+  }
   private DefinitionPane getDefinitionPane() {
     if( this.definitionPane == null ) {
       this.definitionPane = createDefinitionPane();
+    }
     return this.definitionPane;
+  }
   private Options getOptions() {
     return this.options;
+  }
   private Snitch getSnitch() {
     return this.snitch;
+  }
   private Notifier getNotifier() {
     return this.notifier;
+  }
   public void setMenuBar( final MenuBar menuBar ) {
     this.menuBar = menuBar;
+  }
   public MenuBar getMenuBar() {
     return this.menuBar;
+  }
   private Text getLineNumberText() {
     if( this.lineNumberText == null ) {
       this.lineNumberText = createLineNumberText();
+    }
     return this.lineNumberText;
+  }
   private synchronized StatusBar getStatusBar() {
     if( this.statusBar == null ) {
       this.statusBar = createStatusBar();
+    }
     return this.statusBar;
+  }
   private TextField getFindTextField() {
     if( this.findTextField == null ) {
       this.findTextField = createFindTextField();
+    }
     return this.findTextField;
+  }
   //---- Member creators ----------------------------------------------------
   /**
    * Factory to create processors that are suited to different file types.
+   *
    * @param tab The tab that is subjected to processing.
+   *
    * @return A processor suited to the file type specified by the tab's path.
    */
   private Processor<String> createProcessor( final FileEditorTab tab ) {
     return createProcessorFactory().createProcessor( tab );
+  }
   private ProcessorFactory createProcessorFactory() {
     return new ProcessorFactory( getPreviewPane(), getResolvedMap() );
+  }
   private DefinitionSource createDefinitionSource( final String path ) {
     final DefinitionSource ds
       = createDefinitionFactory().createDefinitionSource( path );
     if( ds instanceof FileDefinitionSource ) {
       try {
         getSnitch().listen( ((FileDefinitionSource)ds).getPath() );
       } catch( final IOException ex ) {
         error( ex );
+      }
+    }
     return ds;
+  }
   private TextField createFindTextField() {
     return new TextField();
+  }
   /**
    * Create an editor pane to hold file editor tabs.
+   *
    * @return A new instance, never null.
    */
   private FileEditorTabPane createFileEditorPane() {
     return new FileEditorTabPane();
+  }
   private HTMLPreviewPane createPreviewPane() {
     return new HTMLPreviewPane();
+  }
   private DefinitionPane createDefinitionPane() {
     return new DefinitionPane( getTreeView() );
+  }
   private DefinitionFactory createDefinitionFactory() {
     return new DefinitionFactory();
+  }
   private StatusBar createStatusBar() {
     return new StatusBar();
+  }
   private Scene createScene() {
     final SplitPane splitPane = new SplitPane(
       getDefinitionPane().getNode(),
       getFileEditorPane().getNode(),
       getPreviewPane().getNode() );
     splitPane.setDividerPositions(
       getFloat( K_PANE_SPLIT_DEFINITION, .10f ),
       getFloat( K_PANE_SPLIT_EDITOR, .45f ),
       getFloat( K_PANE_SPLIT_PREVIEW, .45f ) );
     // See: http://broadlyapplicable.blogspot.ca/2015/03/javafx-capture-restorePreferences-splitpane.html
     final BorderPane borderPane = new BorderPane();
     borderPane.setPrefSize( 1024, 800 );
     borderPane.setTop( createMenuBar() );
     borderPane.setBottom( getStatusBar() );
     borderPane.setCenter( splitPane );
     final VBox box = new VBox();
     box.setAlignment( Pos.BASELINE_CENTER );
     box.getChildren().add( getLineNumberText() );
     getStatusBar().getRightItems().add( box );
     return new Scene( borderPane );
+  }
   private Text createLineNumberText() {
     return new Text( get( STATUS_BAR_LINE, 1, 1, 1 ) );
+  }
   private Node createMenuBar() {
     final BooleanBinding activeFileEditorIsNull = getFileEditorPane().activeFileEditorProperty().isNull();
     // File actions
     final Action fileNewAction = new Action( get( "Main.menu.file.new" ), "Shortcut+N", FILE_ALT, e -> fileNew() );
     final Action fileOpenAction = new Action( get( "Main.menu.file.open" ), "Shortcut+O", FOLDER_OPEN_ALT, e -> fileOpen() );
     final Action fileCloseAction = new Action( get( "Main.menu.file.close" ), "Shortcut+W", null, e -> fileClose(), activeFileEditorIsNull );
     final Action fileCloseAllAction = new Action( get( "Main.menu.file.close_all" ), null, null, e -> fileCloseAll(), activeFileEditorIsNull );
     final Action fileSaveAction = new Action( get( "Main.menu.file.save" ), "Shortcut+S", FLOPPY_ALT, e -> fileSave(),
       createActiveBooleanProperty( FileEditorTab::modifiedProperty ).not() );
     final Action fileSaveAsAction = new Action( Messages.get( "Main.menu.file.save_as" ), null, null, e -> fileSaveAs(), activeFileEditorIsNull );
     final Action fileSaveAllAction = new Action( get( "Main.menu.file.save_all" ), "Shortcut+Shift+S", null, e -> fileSaveAll(),
       Bindings.not( getFileEditorPane().anyFileEditorModifiedProperty() ) );
     final Action fileExitAction = new Action( get( "Main.menu.file.exit" ), null, null, e -> fileExit() );
     // Edit actions
     final Action editUndoAction = new Action( get( "Main.menu.edit.undo" ), "Shortcut+Z", UNDO,
       e -> getActiveEditor().undo(),
       createActiveBooleanProperty( FileEditorTab::canUndoProperty ).not() );
     final Action editRedoAction = new Action( get( "Main.menu.edit.redo" ), "Shortcut+Y", REPEAT,
       e -> getActiveEditor().redo(),
       createActiveBooleanProperty( FileEditorTab::canRedoProperty ).not() );
     final Action editFindAction = new Action( Messages.get( "Main.menu.edit.find" ), "Ctrl+F", SEARCH,
       e -> find(),
       activeFileEditorIsNull );
     final Action editReplaceAction = new Action( Messages.get( "Main.menu.edit.find.replace" ), "Shortcut+H", RETWEET,
       e -> getActiveEditor().replace(),
       activeFileEditorIsNull );
     final Action editFindNextAction = new Action( Messages.get( "Main.menu.edit.find.next" ), "F3", null,
       e -> findNext(),
       activeFileEditorIsNull );
     final Action editFindPreviousAction = new Action( Messages.get( "Main.menu.edit.find.previous" ), "Shift+F3", null,
       e -> getActiveEditor().findPrevious(),
       activeFileEditorIsNull );
     // Insert actions
     final Action insertBoldAction = new Action( get( "Main.menu.insert.bold" ), "Shortcut+B", BOLD,
       e -> getActiveEditor().surroundSelection( "**", "**" ),
       activeFileEditorIsNull );
     final Action insertItalicAction = new Action( get( "Main.menu.insert.italic" ), "Shortcut+I", ITALIC,
       e -> getActiveEditor().surroundSelection( "*", "*" ),
       activeFileEditorIsNull );
     final Action insertSuperscriptAction = new Action( get( "Main.menu.insert.superscript" ), "Shortcut+[", SUPERSCRIPT,
       e -> getActiveEditor().surroundSelection( "^", "^" ),
       activeFileEditorIsNull );
     final Action insertSubscriptAction = new Action( get( "Main.menu.insert.subscript" ), "Shortcut+]", SUBSCRIPT,
       e -> getActiveEditor().surroundSelection( "~", "~" ),
       activeFileEditorIsNull );
     final Action insertStrikethroughAction = new Action( get( "Main.menu.insert.strikethrough" ), "Shortcut+T", STRIKETHROUGH,
       e -> getActiveEditor().surroundSelection( "~~", "~~" ),
       activeFileEditorIsNull );
     final Action insertBlockquoteAction = new Action( get( "Main.menu.insert.blockquote" ), "Ctrl+Q", QUOTE_LEFT, // not Shortcut+Q because of conflict on Mac
       e -> getActiveEditor().surroundSelection( "\n\n> ", "" ),
       activeFileEditorIsNull );
     final Action insertCodeAction = new Action( get( "Main.menu.insert.code" ), "Shortcut+K", CODE,
       e -> getActiveEditor().surroundSelection( "`", "`" ),
       activeFileEditorIsNull );
     final Action insertFencedCodeBlockAction = new Action( get( "Main.menu.insert.fenced_code_block" ), "Shortcut+Shift+K", FILE_CODE_ALT,
       e -> getActiveEditor().surroundSelection( "\n\n```\n", "\n```\n\n", get( "Main.menu.insert.fenced_code_block.prompt" ) ),
       activeFileEditorIsNull );
     final Action insertLinkAction = new Action( get( "Main.menu.insert.link" ), "Shortcut+L", LINK,
       e -> getActiveEditor().insertLink(),
       activeFileEditorIsNull );
     final Action insertImageAction = new Action( get( "Main.menu.insert.image" ), "Shortcut+G", PICTURE_ALT,
       e -> getActiveEditor().insertImage(),
       activeFileEditorIsNull );
     final Action[] headers = new Action[ 6 ];
     // Insert header actions (H1 ... H6)
     for( int i = 1; i <= 6; i++ ) {
       final String hashes = new String( new char[ i ] ).replace( "\0", "#" );
       final String markup = String.format( "%n%n%s ", hashes );
       final String text = get( "Main.menu.insert.header_" + i );
       final String accelerator = "Shortcut+" + i;
       final String prompt = get( "Main.menu.insert.header_" + i + ".prompt" );
       headers[ i - 1 ] = new Action( text, accelerator, HEADER,
         e -> getActiveEditor().surroundSelection( markup, "", prompt ),
         activeFileEditorIsNull );
+    }
     final Action insertUnorderedListAction = new Action(
       get( "Main.menu.insert.unordered_list" ), "Shortcut+U", LIST_UL,
       e -> getActiveEditor().surroundSelection( "\n\n* ", "" ),
       activeFileEditorIsNull );
     final Action insertOrderedListAction = new Action(
       get( "Main.menu.insert.ordered_list" ), "Shortcut+Shift+O", LIST_OL,
       e -> getActiveEditor().surroundSelection( "\n\n1. ", "" ),
       activeFileEditorIsNull );
     final Action insertHorizontalRuleAction = new Action(
       get( "Main.menu.insert.horizontal_rule" ), "Shortcut+H", null,
       e -> getActiveEditor().surroundSelection( "\n\n---\n\n", "" ),
       activeFileEditorIsNull );
     // Tools actions
     final Action toolsScriptAction = new Action(
       get( "Main.menu.tools.script" ), null, null, e -> toolsScript() );
     // Help actions
     final Action helpAboutAction = new Action(
       get( "Main.menu.help.about" ), null, null, e -> helpAbout() );
     //---- MenuBar ----
     final Menu fileMenu = ActionUtils.createMenu( get( "Main.menu.file" ),
       fileNewAction,
       fileOpenAction,
       null,
       fileCloseAction,
       fileCloseAllAction,
       null,
       fileSaveAction,
       fileSaveAsAction,
       fileSaveAllAction,
       null,

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

     removeItem.setOnAction( (ActionEvent e) -> {
       final TreeItem c = getTreeItem();
       boolean remove = c.getParent().getChildren().remove( c );
       System.out.println( "Remove" );
       c.getParent().getChildren().remove( c );
     } );

M src/main/java/com/scrivenvar/definition/yaml/YamlParser.java

    */
   private void resolve(
     final JsonNode rootNode, final String path, final Map<String, String> map ) {
     final JsonNode rootNode,
     final String path,
     final Map<String, String> map ) {
     if( rootNode != null ) {

M src/main/java/com/scrivenvar/dialogs/RScriptDialog.java

   private TextArea scriptArea;
   private String originalText = "";
   public RScriptDialog(
     final Window parent, final String title, final String script ) {
     super( parent, title );
     setOriginalText( script );
     getScriptArea().setText( script );
+  }
     setResultConverter( dialogButton -> {
       return dialogButton == OK ? textArea.getText() : "";
       return dialogButton == OK ? textArea.getText() : getOriginalText();
     } );
+  }
   private TextArea getScriptArea() {
     if( this.scriptArea == null ) {
       this.scriptArea = new TextArea();
+    }
     return this.scriptArea;
+  }
   private String getOriginalText() {
     return this.originalText;
+  }
   private void setOriginalText( final String originalText ) {
     this.originalText = originalText;
+  }
+}

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

    getUndoManager().redo();
  }
  

  /**
   * TOD: Implement this.
   */
  public void replace() {
    System.out.println( "replace" );
  }
  

  /**
   * TOD: Implement this.
   */
  public void findPrevious() {
    System.out.println( "find previous" );
  }


M src/main/java/com/scrivenvar/editors/markdown/MarkdownEditorPane.java

 import org.fxmisc.richtext.StyleClassedTextArea;
 import static org.fxmisc.wellbehaved.event.EventPattern.keyPressed;
 import static org.fxmisc.wellbehaved.event.EventPattern.keyPressed;
 import static org.fxmisc.wellbehaved.event.EventPattern.keyPressed;
 import static org.fxmisc.wellbehaved.event.EventPattern.keyPressed;
 /**
     addEventListener( keyPressed( ENTER ), this::enterPressed );
     // TODO: Wait for implementation that allows cutting lines, not paragraphs.
 //    addEventListener( keyPressed( X, SHORTCUT_DOWN ), this::cutLine );
+  }

A src/main/java/com/scrivenvar/processors/IdentityProcessor.java

 /*
  * Copyright 2017 White Magic Software, Ltd.
+ *
  * All rights reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
+ *
  *  o Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
+ *
  *  o Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 package com.scrivenvar.processors;
 /**
  * This is the default processor used when an unknown filename extension is
  * encountered.
+ *
  * @author White Magic Software, Ltd.
  */
 public class IdentityProcessor extends AbstractProcessor<String> {
   /**
    * Passes the link to the super constructor.
+   *
    * @param link The next processor in the chain to use for text processing.
    */
   public IdentityProcessor( final Processor<String> link ) {
     super( link );
+  }
   /**
    * Returns the given string, modified with "pre" tags.
+   *
    * @param t The string to return, enclosed in "pre" tags.
+   *
    * @return t
    */
   @Override
   public String processLink( final String t ) {
     final StringBuilder result = new StringBuilder( t.length() + 16 );
     return result.append( "<pre>" ).append( t ).append( "</pre>" ).toString();
+  }
+}

M src/main/java/com/scrivenvar/processors/ProcessorFactory.java

   public Processor<String> createProcessor( final FileEditorTab tab ) {
     final Path path = tab.getPath();
     Processor<String> processor = null;
     final Processor<String> processor;
     switch( lookup( path ) ) {
       default:
         unknownExtension( path );
         processor = createIdentityProcessor( tab );
         break;
+    }
     return mpp;
+  }
   protected Processor<String> createIdentityProcessor( final FileEditorTab tab ) {
     final Processor<String> hpp = new HTMLPreviewProcessor( getPreviewPane() );
     final Processor<String> ip = new IdentityProcessor( hpp );
     return ip;
+  }

A src/main/r/README.md

 # R Scripts
 These R scripts illustrate how R can be used within an application to perform calculations using variables. Authors are free to write their own scripts, of course. These scripts serve as an example of how to automate certain tasks while writing.
 ## Configuration
 Configure the editor to use the R scripts as follows:
 . Copy the R scripts into same directory as your Markdown files.
 . Start the editor.
 . Click **Tools → R Script**.
 . Copy and paste the following:
         assign( 'anchor', as.Date( '$date.anchor$', format='%Y-%m-%d' ), envir = .GlobalEnv );
         setwd( '$application.r.working.directory$' );
         source( 'pluralize.R' );
         source( 'csv.R' );
         source( 'conversion.R' );
 . Click **File → New** to create a new file.
 . Click **File → Save As** to set a filename.
 . Set **Name** to: `variables.yaml`
 . Click **OK**.
 . Paste the following definitions:
        date:
          anchor: 2017-01-01
        editor:
          examples:
            season: 2017-09-02
            math:
              x: 1
              y: $editor.examples.math.x$ + 1
              z: $editor.examples.math.y$ + 1
            name:
              given: Josephene
 . Save and close the file.
 . Click **File → Open**
 . Change **Markdown Files** to **Definition Files**.
 . Select `variables.yaml`.
 . Click **Open**.
 R functionality is configured.
 ## Definitions
 The variables definitions within `variables.yaml` are available to R using the R syntax. An additional variable, `application.r.working.directory` is added to the list of variables. The value is set to the working directory of the file being edited. Hover the mouse cursor over the file tab in the editor to see the full path to the file.
 ## Examples
 This section demonstrates how to use the R functions when editing. Complete the following steps to begin:
 . Click **File → New** to create a new file.
 . Click **File → Save As** to set a filename.
 . Set **Name** to: `example.Rmd`
 . Click **OK**.
 The examples are ready for use within the editor.
 ### Arithmetic
 Type the following to perform a simple calculation:
     `r# 1+1`
 The preview pane shows `2.0`.
 ### Functions
 Call the [format](https://stat.ethz.ch/R-manual/R-devel/library/base/html/format.html) function to truncate unwanted decimal places as follows:
     `r# format(1+1,digits=1)`
 The preview pane shows `2`.
 ### Pluralize
 Many English words can be pluralized as follows:
     `r# pl('wolf',2)`
 The preview pane shows `wolves`. The `pluralize.R` file contains a partial implementation of Damian Conway's algorithmic approach to English pluralization.
 ### Chicago Manual of Style
 Apply the Chicago Manual of Style for words less than one-hundred as follows:
        `r# cms(1)` `r# cms(99)` `r# cms(101)`
 The preview pane shows numbers written out as `one` and `ninety-nine`, followed by the digits 101.
 ### Data Import
 Import and display information from a CSV file as follows:
 . Click **File → New** to create a new file.
 . Click **File → Save As** to rename the file.
 . Set the filename to: `data.csv`
 . Paste the following into `data.csv`:
         Animal,Quantity,Country
         Aardwolf,1,Africa
         Keel-billed toucan,1,Belize
         Beaver,2,Canada
         Mute swan,3,Denmark
         Lion,5,Ethiopia
         Brown bear,8,Finland
         Dolphin,13,Greece
         Turul,21,Hungary
         Gyrfalcon,34,Iceland
         Red-billed streamertail,55,Jamaica
 . Click the `example.Rmd` tab.
 . Type the following:
        `r# csv2md('data.csv',total=F)`
 . Type the following to sum all numeric columns, use:
        `r# csv2md('data.csv')`
 This imports the data from an external file and formats the information into a table, automatically. Update the data as follows:
 . Click the `data.csv` tab to edit the data.
 . Change the data by adding a new row.
 . Save the file.
 . Click the `example.Rmd` tab.
 The preview pane shows the revised contents.
 ### Elapsed Time
 The duration of a timeline, given in numbers of days, can be computed into English as follows:
     `r# elapsed(1,1)`
 The preview pane shows `same day`. Change the expression to:
     `r# elapsed(1,2)`
 The preview pane shows `one day`. Change the expression to:
     `r# elapsed(1,112358)`
 The preview pane shows `307 years, seven months, and sixteen days`, combined using the Chicago Manual of Style, the pluralization function, and a [serial comma](https://www.behance.net/gallery/19417363/The-Oxford-Comma).
 ### Variable Syntax
 The syntax for a variable changes when using an R Markdown file (denoted by the `.Rmd` filename extension), as opposed to a regular Markdown file (`.md`). Return to the example file and type the following:
     `r# v$date$anchor`
 The preview pane shows the date.
 ### Autocomplete
 Automatically insert a variable reference into the text as follows:
 . Type: `Jos`
     * Note the capital letter, matches are case sensitive.
 . Hold down the `Control` key.
 . Tap the `Spacebar`
 The editor shows:
     `r#x( v$editor$examples$name$given )`
 The preview pane shows:
     Josephine
 Here, the `x` function evaluates its parameter as an expression. This allows variables to include expressions in their definition.
 ### Variable Definition Expressions
 Definition file variables are have the ability to reference other definitions. Try the following:
     `r#x( v$editor$examples$math$x )`
     `r#x( v$editor$examples$math$y )`
     `r#x( v$editor$examples$math$z )`
 The preview pane shows:
     x = 1.0; y = 2.0; z = 3.0
 ### Case
 Ensure words begin with a lowercase letter as follows:
     `r#lc( v$editor$examples$name$given )`
 The preview pane shows:
     josephine
 Similarly, ensure an uppercase letter as follows:
     `r#uc( 'hello, world!' )`
 The preview pane shows:
     Hello, world!
 ### Month
 Display the month name given a month number as follows:
     `r# month( 1 )`
 The preview pane shows:
     January
 ## Summary
 Authors can inline R statements into documents, directly, so long as those statements generate text. Plots, graphs, and images must be referenced as external image files or URLs.

A src/main/r/conversion.R

 # ########################################################################
+#
 # Substitute R expressions in a document with their evaluated value. The
 # anchor variable must be set for functions that use relative dates.
+#
 # ########################################################################
 # Evaluates an expression; writes s if there is no expression.
 x <- function( s ) {
   return(
     tryCatch({
       r = eval( parse( text=s ) )
       # If the result isn't primitive, then it was probably parsed into
       # an unprintable object (e.g., "gray" becomes a colour). In those
       # cases, return the original text string. Otherwise, an atomic
       # value means a primitive type (string, integer, etc.) that can be
       # written directly into the document.
+      #
       # See: http://stackoverflow.com/a/19501276/59087
       if( is.atomic( r ) ) {
+        r
+      }
       else {
+        s
+      }
     },
     warning = function( w ) {
+      s
     },
     error = function( e ) {
+      s
     })
+  )
+}
 # Returns a date offset by a given number of days, relative to the given
 # date (d). This does not use the anchor, but is used to get the anchor's
 # value as a date.
 when <- function( d, n = 0, format = "%Y-%m-%d" ) {
   as.Date( d, format = format ) + x( n )
+}
 # Full date (s) offset by an optional number of days before or after.
 # This will remove leading zeros (applying leading spaces instead, which
 # are ignored by any worthwhile typesetting engine).
 annal <- function( days = 0, format = "%Y-%m-%d", oformat = "%B %d, %Y" ) {
   format( when( anchor, days ), format = oformat )
+}
 # Extracts the year from a date string.
 year <- function( days = 0, format = "%Y-%m-%d" ) {
   annal( days, format, "%Y" )
+}
 # Day of the week (in days since the anchor date).
 weekday <- function( n ) {
   weekdays( when( anchor, n ) )
+}
 # String concatenate function alias because paste0 is a terrible name.
 concat <- paste0
 # Translates a number from digits to words using Chicago Manual of Style.
 # This does not translate numbers greater than one hundred. If ordinal
 # is TRUE, this will return the ordinal name. This will not produce ordinals
 # for numbers greater than 100
 cms <- function( n, ordinal = FALSE ) {
   n <- x( n )
   # We're done here.
   if( n == 0 ) {
     if( ordinal ) {
       return( "zeroth" )
+    }
     return( "zero" )
+  }
   # Concatenate this a little later.
   if( n < 0 ) {
     result = "negative "
     n = abs( n )
+  }
   # Do not spell out numbers greater than one hundred.
   if( n > 100 ) {
     # Comma-separated numbers.
     return( format( n, big.mark=",", trim=TRUE, scientific=FALSE ) )
+  }
   # Don't go beyond 100.
   if( n == 100 ) {
     if( ordinal ) {
       return( "one hundredth" )
+    }
     return( "one hundred" )
+  }
   # Samuel Langhorne Clemens noted English has too many exceptions.
   small = c(
     "one", "two", "three", "four", "five",
     "six", "seven", "eight", "nine", "ten",
     "eleven", "twelve", "thirteen", "fourteen", "fifteen",
     "sixteen", "seventeen", "eighteen", "nineteen"
+  )
   ord_small = c(
     "first", "second", "third", "fourth", "fifth",
     "sixth", "seventh", "eighth", "ninth", "tenth",
     "eleventh", "twelfth", "thirteenth", "fourteenth", "fifteenth",
     "sixteenth", "seventeenth", "eighteenth", "nineteenth", "twentieth"
+  )
   # After this, the number (n) is between 20 and 99.
   if( n < 20 ) {
     if( ordinal ) {
       return( .subset( ord_small, n %% 100 ) )
+    }
     return( .subset( small, n %% 100 ) )
+  }
   tens = c( "",
     "twenty", "thirty", "forty", "fifty",
     "sixty", "seventy", "eighty", "ninety"
+  )
   ord_tens = c( "",
     "twentieth", "thirtieth", "fortieth", "fiftieth",
     "sixtieth", "seventieth", "eightieth", "ninetieth"
+  )
   ones_index = n %% 10
   n = n %/% 10
   # No number in the ones column, so the number must be a multiple of ten.
   if( ones_index == 0 ) {
     if( ordinal ) {
       return( .subset( ord_tens, n ) )
+    }
     return( .subset( tens, n ) )
+  }
   # Find the value from the ones column.
   if( ordinal ) {
     unit_1 = .subset( ord_small, ones_index )
+  }
   else {
     unit_1 = .subset( small, ones_index )
+  }
   # Find the tens column.
   unit_10 = .subset( tens, n )
   # Hyphenate the tens and the ones together.
   concat( unit_10, concat( "-", unit_1 ) )
+}
 # Returns a human-readable string that provides the elapsed time between
 # two numbers in terms of years, months, and days. If any unit value is zero,
 # the unit is not included. The words (year, month, day) are pluralized
 # according to English grammar. The numbers are written out according to
 # Chicago Manual of Style. This applies the serial comma.
+#
 # Both numbers are offsets relative to the anchor date.
+#
 # If all unit values are zero, this returns s ("same day" by default).
+#
 # If the start date (began) is greater than end date (ended), the dates are
 # swapped before calculations are performed. This allows any two dates
 # to be compared and positive unit values are always returned.
+#
 elapsed <- function( began, ended, s = "same day" ) {
   began = when( anchor, began )
   ended = when( anchor, ended )
   # Swap the dates if the end date comes before the start date.
   if( as.integer( ended - began ) < 0 ) {
     tempd = began
     began = ended
     ended = tempd
+  }
   # Calculate number of elapsed years.
   years = length( seq( from = began, to = ended, by = 'year' ) ) - 1
   # Move the start date up by the number of elapsed years.
   if( years > 0 ) {
     began = seq( began, length = 2, by = concat( years, " years" ) )[2]
     years = pl.numeric( "year", years )
+  }
   else {
     # Zero years.
     years = ""
+  }
   # Calculate number of elapsed months, excluding years.
   months = length( seq( from = began, to = ended, by = 'month' ) ) - 1
   # Move the start date up by the number of elapsed months
   if( months > 0 ) {
     began = seq( began, length = 2, by = concat( months, " months" ) )[2]
     months = pl.numeric( "month", months )
+  }
   else {
     # Zero months
     months = ""
+  }
   # Calculate number of elapsed days, excluding months and years.
   days = length( seq( from = began, to = ended, by = 'day' ) ) - 1
   if( days > 0 ) {
     days = pl.numeric( "day", days )
+  }
   else {
     # Zero days
     days = ""
+  }
   if( years <= 0 && months <= 0 && days <= 0 ) {
     return( s )
+  }
   # Put them all in a vector, then remove the empty values.
   s <- c( years, months, days )
   s <- s[ s != "" ]
   r <- paste( s, collapse = ", " )
   # If all three items are present, replace the last comma with ", and".
   if( length( s ) > 2 ) {
     return( gsub( "(.*),", "\\1, and", r ) )
+  }
   # Does nothing if no commas are present.
   gsub( "(.*),", "\\1 and", r )
+}
 # Returns the number (n) in English followed by the plural or singular
 # form of the given string (s; resumably a noun), if applicable, according
 # to English grammar. That is, pl.numeric( "wolf", 5 ) will return
 # "five wolves".
 pl.numeric <- function( s, n ) {
   concat( cms( n ), concat( " ", pluralize( s, n ) ) )
+}
 # Name of the season, starting with an capital letter.
 season <- function( n, format = "%Y-%m-%d" ) {
   WS <- as.Date("2016-12-15", "%Y-%m-%d") # Winter Solstice
   SE <- as.Date("2016-03-15", "%Y-%m-%d") # Spring Equinox
   SS <- as.Date("2016-06-15", "%Y-%m-%d") # Summer Solstice
   AE <- as.Date("2016-09-15", "%Y-%m-%d") # Autumn Equinox
   d <- when( anchor, n )
   d <- as.Date( strftime( d, format="2016-%m-%d" ) )
   ifelse( d >= WS | d < SE, "Winter",
     ifelse( d >= SE & d < SS, "Spring",
       ifelse( d >= SS & d < AE, "Summer", "Autumn" )
+    )
+  )
+}
 # Converts the first letter in a string to lowercase
 lc <- function( s ) {
   concat( tolower( substr( s, 1, 1 ) ), substr( s, 2, nchar( s ) ) )
+}
 # Converts the first letter in a string to uppercase
 uc <- function( s ) {
   concat( toupper( substr( s, 1, 1 ) ), substr( s, 2, nchar( s ) ) )
+}
 # Returns the number of days between the given dates.
 days <- function( d1, d2, format = "%Y-%m-%d" ) {
   dates = c( d1, d2 )
   dt = strptime( dates, format = format )
   as.integer( difftime( dates[2], dates[1], units = "days" ) )
+}
 # Returns the number of years elapsed.
 years <- function( began, ended ) {
   began = when( anchor, began )
   ended = when( anchor, ended )
   # Swap the dates if the end date comes before the start date.
   if( as.integer( ended - began ) < 0 ) {
     tempd = began
     began = ended
     ended = tempd
+  }
   # Calculate number of elapsed years.
   length( seq( from = began, to = ended, by = 'year' ) ) - 1
+}
 # Full name of the month, starting with a capital letter.
 month <- function( n ) {
   # Faster than month.name[ x( n ) ]
   .subset( month.name, x( n ) )
+}
 money <- function( n ) {
   formatC( x( n ), format="d" )
+}

A src/main/r/csv.R

 # ######################################################################
+#
 # Copyright 2016, White Magic Software, Ltd.
+#
 # Permission is hereby granted, free of charge, to any person obtaining
 # a copy of this software and associated documentation files (the
 # "Software"), to deal in the Software without restriction, including
 # without limitation the rights to use, copy, modify, merge, publish,
 # distribute, sublicense, and/or sell copies of the Software, and to
 # permit persons to whom the Software is furnished to do so, subject to
 # the following conditions:
+#
 # The above copyright notice and this permission notice shall be
 # included in all copies or substantial portions of the Software.
+#
 # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 # EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 # MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 # NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
 # LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
 # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#
 # ######################################################################
 # ######################################################################
+#
 # Converts CSV to Markdown.
+#
 # ######################################################################
 # Reads a CSV file and converts the contents to a Markdown table. The
 # file must be in the working directory as specified by setwd.
+#
 # @param f The filename to convert.
 # @param decimals Rounded decimal places (default 1).
 # @param totals Include total sums (default TRUE).
 # @param align Right-align numbers (default TRUE).
 csv2md <- function( f, decimals = 1, totals = T, align = T ) {
   # Read the CVS data from the file; ensure strings become characters.
   df <- read.table( f, sep=',', header=T, stringsAsFactors=F )
   if( totals ) {
     # Determine what columns can be summed.
     number <- which( unlist( lapply( df, is.numeric ) ) )
     # Use colSums when more than one summable column exists.
     if( length( number ) > 1 ) {
       f.sum <- colSums
+    }
     else {
       f.sum <- sum
+    }
     # Calculate the sum of all the summable columns and insert the
     # results back into the data frame.
     df[ (nrow( df ) + 1), number ] <- f.sum( df[, number], na.rm=TRUE )
     # pluralize would be heavyweight here.
     if( length( number ) > 1 ) {
       t <- "**Totals**"
+    }
     else {
       t <- "**Total**"
+    }
     # Change the first column of the last line to "Total(s)".
     df[ nrow( df ), 1 ] <- t
     # Don't clutter the output with "NA" text.
     df[ is.na( df ) ] <- ""
+  }
   if( align ) {
     is.char <- vapply( df, is.character, logical( 1 ) )
     dashes <- paste( ifelse( is.char, ':---', '---:' ), collapse='|' )
+  }
   else {
     dashes <- paste( rep( '---', length( df ) ), collapse = '|')
+  }
   # Create a Markdown version of the data frame.
   paste(
     paste( names( df ), collapse = '|'), '\n',
     dashes, '\n',
     paste(
       Reduce( function( x, y ) {
           paste( x, format( y, digits = decimals ), sep = '|' )
         }, df
       ),
       collapse = '|\n', sep=''
+    )
+  )
+}

A src/main/r/pluralize.R

 # ######################################################################
+#
 # Copyright 2016, White Magic Software, Ltd.
+#
 # Permission is hereby granted, free of charge, to any person obtaining
 # a copy of this software and associated documentation files (the
 # "Software"), to deal in the Software without restriction, including
 # without limitation the rights to use, copy, modify, merge, publish,
 # distribute, sublicense, and/or sell copies of the Software, and to
 # permit persons to whom the Software is furnished to do so, subject to
 # the following conditions:
+#
 # The above copyright notice and this permission notice shall be
 # included in all copies or substantial portions of the Software.
+#
 # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 # EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 # MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 # NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
 # LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
 # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#
 # ######################################################################
 # ######################################################################
+#
 # See Damian Conway's "An Algorithmic Approach to English Pluralization":
 #   http://goo.gl/oRL4MP
 # See Oliver Glerke's Evo Inflector: https://github.com/atteo/evo-inflector/
 # See Shevek's Pluralizer: https://github.com/shevek/linguistics/
 # See also: http://www.freevectors.net/assets/files/plural.txt
+#
 # ######################################################################
 pluralize <- function( s, n ) {
   result <- s
   # Partial implementation of Conway's algorithm for nouns.
   if( n != 1 ) {
     if( pl.noninflective( s ) ||
         pl.suffix( "fish", s ) ||
         pl.suffix( "ois", s ) ||
         pl.suffix( "sheep", s ) ||
         pl.suffix( "deer", s ) ||
         pl.suffix( "pox", s ) ||
         pl.suffix( "[A-Z].*ese", s ) ||
         pl.suffix( "itis", s ) ) {
       # 1. Retain non-inflective user-mapped noun as is.
       # 2. Retain non-inflective plural as is.
       result <- s
+    }
     else if( pl.is.irregular.pl( s ) ) {
       # 4. Change irregular plurals based on mapping.
       result <- pl.irregular.pl( s )
+    }
     else if( pl.is.irregular.es( s ) ) {
       # x. From Shevek's Pluralizer
       result <- pl.inflect( s, "", "es" )
+    }
     else if( pl.suffix( "man", s ) ) {
       # 5. For -man, change -an to -en
       result <- pl.inflect( s, "an", "en" )
+    }
     else if( pl.suffix( "[lm]ouse", s ) ) {
       # 5. For [lm]ouse, change -ouse to -ice
       result <- pl.inflect( s, "ouse", "ice" )
+    }
     else if( pl.suffix( "tooth", s ) ) {
       # 5. For -tooth, change -ooth to -eeth
       result <- pl.inflect( s, "ooth", "eeth" )
+    }
     else if( pl.suffix( "goose", s ) ) {
       # 5. For -goose, change -oose to -eese
       result <- pl.inflect( s, "oose", "eese" )
+    }
     else if( pl.suffix( "foot", s ) ) {
       # 5. For -foot, change -oot to -eet
       result <- pl.inflect( s, "oot", "eet" )
+    }
     else if( pl.suffix( "zoon", s ) ) {
       # 5. For -zoon, change -on to -a
       result <- pl.inflect( s, "on", "a" )
+    }
     else if( pl.suffix( "[csx]is", s ) ) {
       # 5. Change -cis, -sis, -xis to -es
       result <- pl.inflect( s, "is", "es" )
+    }
     else if( pl.suffix( "([cs]h|ss)", s ) ) {
       # 8. Change -ch, -sh, -ss to -es
       result <- pl.inflect( s, "", "es" )
+    }
     else if( pl.suffix( "([aeo]lf|[^d]eaf|arf)", s ) ) {
       # 9. Change -f to -ves
       result <- pl.inflect( s, "f", "ves" )
+    }
     else if( pl.suffix( "[nlw]ife", s ) ) {
       # 9. Change -fe to -ves
       result <- pl.inflect( s, "fe", "ves" )
+    }
     else if( pl.suffix( "([aeiou]y|[A-Z].*y)", s ) ) {
       # 10. Change -y to -ys.
       result <- pl.inflect( s, "", "s" )
+    }
     else if( pl.suffix( "y", s ) ) {
       # 10. Change -y to -ies.
       result <- pl.inflect( s, "y", "ies" )
+    }
     else {
       # 13. Default plural: add -s.
       result <- pl.inflect( s, "", "s" )
+    }
+  }
   result
+}
 # Pluralize s if n is not equal to 1.
 pl <- function( s, n ) {
   pluralize( s, x( n ) )
+}
 # Returns the given string (s) with its suffix replaced by r.
 pl.inflect <- function( s, suffix, r ) {
   gsub( paste( suffix, "$", sep="" ), r, s )
+}
 # Answers whether the given string (s) has the given ending.
 pl.suffix <- function( ending, s ) {
   grepl( paste( ending, "$", sep="" ), s )
+}
 # Answers whether the given string (s) is a noninflective noun.
 pl.noninflective <- function( s ) {
   v <- c(
     "aircraft", "Bhutanese", "bison", "bream", "breeches", "britches",
     "Burmese", "carp", "chassis", "Chinese", "clippers", "cod", "contretemps",
     "corps", "debris", "diabetes", "djinn", "eland", "elk", "flounder",
     "fracas", "gallows", "graffiti", "headquarters", "herpes", "high-jinks",
     "homework", "hovercraft", "innings", "jackanapes", "Japanese",
     "Lebanese", "mackerel", "means", "measles", "mews", "mumps", "news",
     "pincers", "pliers", "Portuguese", "proceedings", "rabies", "salmon",
     "scissors", "sea-bass", "Senegalese", "series", "shears", "Siamese",
     "Sinhalese", "spacecraft", "species", "swine", "trout", "tuna",
     "Vietnamese", "watercraft", "whiting", "wildebeest"
+  )
   is.element( s, v )
+}
 # Answers whether the given string (s) is an irregular plural.
 pl.is.irregular.pl <- function( s ) {
   # Could be refactored with pl.irregular.pl...
   v <- c(
     "beef", "brother", "child", "cow", "ephemeris", "genie", "money",
     "mongoose", "mythos", "octopus", "ox", "soliloquy", "trilby"
+  )
   is.element( s, v )
+}
 # Call to pluralize an irregular noun. Only call after confirming
 # the noun is irregular via pl.is.irregular.pl.
 pl.irregular.pl <- function( s ) {
   v <- list(
     "beef" = "beefs",
     "brother" = "brothers",
     "child" = "children",
     "cow" = "cows",
     "ephemeris" = "ephemerides",
     "genie" = "genies",
     "money" = "moneys",
     "mongoose" = "mongooses",
     "mythos" = "mythoi",
     "octopus" = "octopuses",
     "ox" = "oxen",
     "soliloquy" = "soliloquies",
     "trilby" = "trilbys"
+  )
   # Faster version of v[[ s ]]
   .subset2( v, s )
+}
 # Answers whether the given string (s) pluralizes with -es.
 pl.is.irregular.es <- function( s ) {
   v <- c(
     "acropolis", "aegis", "alias", "asbestos", "bathos", "bias", "bronchitis",
     "bursitis", "caddis", "cannabis", "canvas", "chaos", "cosmos", "dais",
     "digitalis", "epidermis", "ethos", "eyas", "gas", "glottis", "hubris",
     "ibis", "lens", "mantis", "marquis", "metropolis", "pathos", "pelvis",
     "polis", "rhinoceros", "sassafrass", "trellis"
+  )
   is.element( s, v )
+}

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

 Main.menu.file=_File
 Main.menu.file.new=New
 Main.menu.file.open=Open...
 Main.menu.file.close=Close
 Main.menu.file.new=_New
 Main.menu.file.open=_Open...
 Main.menu.file.close=_Close
 Main.menu.file.close_all=Close All
 Main.menu.file.save=Save
 Main.menu.file.save_all=Save All
 Main.menu.file.exit=Exit
 Main.menu.file.save=_Save
 Main.menu.file.save_as=Save _As
 Main.menu.file.save_all=Save A_ll
 Main.menu.file.exit=E_xit
 Main.menu.edit=_Edit

74	74	getUndoManager().redo();
75	75	}
76
	76
	77	/**
	78	* TOD: Implement this.
	79	*/
77	80	public void replace() {
78		System.out.println( "replace" );
79	81	}
80
	82
	83	/**
	84	* TOD: Implement this.
	85	*/
81	86	public void findPrevious() {
82		System.out.println( "find previous" );
83	87	}
84	88