Dave Jarvis' Repositories

<?xml version="1.0" encoding="UTF-8"?>

<classpath>

	<classpathentry kind="src" path="src/main/java">

		<attributes>

			<attribute name="FROM_GRADLE_MODEL" value="true"/>

		</attributes>

	</classpathentry>

	<classpathentry kind="src" path="src/main/resources">

		<attributes>

			<attribute name="FROM_GRADLE_MODEL" value="true"/>

		</attributes>

	</classpathentry>

	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8">

		<accessrules>

			<accessrule kind="accessible" pattern="javafx/**"/>

		</accessrules>

	</classpathentry>

	<classpathentry exported="true" kind="con" path="org.eclipse.buildship.core.gradleclasspathcontainer"/>

	<classpathentry kind="output" path="bin"/>

</classpath>

GRADLE_BUILD_COMMANDS=org.eclipse.jdt.core.javabuilder

GRADLE_NATURES=org.eclipse.jdt.core.javanature

build.commands=org.eclipse.jdt.core.javabuilder

connection.arguments=

connection.gradle.distribution=GRADLE_DISTRIBUTION(WRAPPER)

connection.gradle.user.home=null

connection.java.home=null

connection.jvm.arguments=

connection.project.dir=

derived.resources=.gradle,build

eclipse.preferences.version=1

natures=org.eclipse.jdt.core.javanature

project.path=\:

eclipse.preferences.version=1

line.separator=\n

eclipse.preferences.version=1

org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled

org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.8

org.eclipse.jdt.core.compiler.compliance=1.8

org.eclipse.jdt.core.compiler.problem.assertIdentifier=error

org.eclipse.jdt.core.compiler.problem.enumIdentifier=error

org.eclipse.jdt.core.compiler.source=1.8

eclipse.preferences.version=1

editor_save_participant_org.eclipse.jdt.ui.postsavelistener.cleanup=true

org.eclipse.jdt.ui.ignorelowercasenames=true

org.eclipse.jdt.ui.importorder=java;javafx;javax;org;com;

org.eclipse.jdt.ui.ondemandthreshold=99

org.eclipse.jdt.ui.staticondemandthreshold=99

sp_cleanup.add_default_serial_version_id=true

sp_cleanup.add_generated_serial_version_id=false

sp_cleanup.add_missing_annotations=true

sp_cleanup.add_missing_deprecated_annotations=true

sp_cleanup.add_missing_methods=false

sp_cleanup.add_missing_nls_tags=false

sp_cleanup.add_missing_override_annotations=true

sp_cleanup.add_missing_override_annotations_interface_methods=true

sp_cleanup.add_serial_version_id=false

sp_cleanup.always_use_blocks=true

sp_cleanup.always_use_parentheses_in_expressions=false

sp_cleanup.always_use_this_for_non_static_field_access=false

sp_cleanup.always_use_this_for_non_static_method_access=false

sp_cleanup.convert_functional_interfaces=false

sp_cleanup.convert_to_enhanced_for_loop=false

sp_cleanup.correct_indentation=false

sp_cleanup.format_source_code=false

sp_cleanup.format_source_code_changes_only=false

sp_cleanup.insert_inferred_type_arguments=false

sp_cleanup.make_local_variable_final=false

sp_cleanup.make_parameters_final=false

sp_cleanup.make_private_fields_final=true

sp_cleanup.make_type_abstract_if_missing_method=false

sp_cleanup.make_variable_declarations_final=true

sp_cleanup.never_use_blocks=false

sp_cleanup.never_use_parentheses_in_expressions=true

sp_cleanup.on_save_use_additional_actions=true

sp_cleanup.organize_imports=false

sp_cleanup.qualify_static_field_accesses_with_declaring_class=false

sp_cleanup.qualify_static_member_accesses_through_instances_with_declaring_class=true

sp_cleanup.qualify_static_member_accesses_through_subtypes_with_declaring_class=true

sp_cleanup.qualify_static_member_accesses_with_declaring_class=false

sp_cleanup.qualify_static_method_accesses_with_declaring_class=false

sp_cleanup.remove_private_constructors=true

sp_cleanup.remove_redundant_type_arguments=true

sp_cleanup.remove_trailing_whitespaces=true

sp_cleanup.remove_trailing_whitespaces_all=true

sp_cleanup.remove_trailing_whitespaces_ignore_empty=false

sp_cleanup.remove_unnecessary_casts=true

sp_cleanup.remove_unnecessary_nls_tags=false

sp_cleanup.remove_unused_imports=true

sp_cleanup.remove_unused_local_variables=false

sp_cleanup.remove_unused_private_fields=true

sp_cleanup.remove_unused_private_members=false

sp_cleanup.remove_unused_private_methods=true

sp_cleanup.remove_unused_private_types=true

sp_cleanup.sort_members=false

sp_cleanup.sort_members_all=false

sp_cleanup.use_anonymous_class_creation=false

sp_cleanup.use_blocks=false

sp_cleanup.use_blocks_only_for_return_and_throw=false

sp_cleanup.use_lambda=true

sp_cleanup.use_parentheses_in_expressions=false

sp_cleanup.use_this_for_non_static_field_access=false

sp_cleanup.use_this_for_non_static_field_access_only_if_necessary=true

sp_cleanup.use_this_for_non_static_method_access=false

sp_cleanup.use_this_for_non_static_method_access_only_if_necessary=true

sp_cleanup.use_type_arguments=false

This software is licensed under the [BSD 2-Clause License](LICENSE.md).

// Assume an überjar unless targetOs is set.

  implementation 'com.fasterxml.jackson.core:jackson-core:2.11.0'

  implementation 'com.fasterxml.jackson.core:jackson-databind:2.11.0'

  implementation 'com.fasterxml.jackson.core:jackson-annotations:2.11.0'

  implementation 'com.fasterxml.jackson.dataformat:jackson-dataformat-yaml:2.11.0'

readonly SCRIPT_DIR="\$(cd "\${SCRIPT_SRC}" >/dev/null 2>&1 && pwd)"

"\${SCRIPT_DIR}/${ARG_JAVA_DIR}/bin/java.exe" -jar "\${SCRIPT_DIR}/${FILE_APP_JAR}" "\$@"

import com.scrivenvar.predicates.files.FileTypePredicate;

import java.util.Iterator;

import java.util.List;

  private final Settings mSettings = Services.load( Settings.class );

    final Settings properties = getSettings();

    final Iterator<String> keys = properties.getKeys( prefix );

    boolean found = false;

    FileType fileType = UNKNOWN;

      final String key = keys.next();

      final List<String> patterns = properties.getStringSettingList( key );

      final FileTypePredicate predicate = new FileTypePredicate( patterns );

    return this.mSettings;

  private static final Settings SETTINGS = Services.load( Settings.class );

import com.scrivenvar.predicates.files.FileTypePredicate;

import com.scrivenvar.service.Options;

import com.scrivenvar.service.Settings;

import com.scrivenvar.service.events.Notification;

import com.scrivenvar.service.events.Notifier;

import com.scrivenvar.util.Utils;

import javafx.beans.property.ReadOnlyBooleanProperty;

import javafx.beans.property.ReadOnlyBooleanWrapper;

import javafx.beans.property.ReadOnlyObjectProperty;

import javafx.beans.property.ReadOnlyObjectWrapper;

import javafx.beans.value.ChangeListener;

import javafx.collections.ListChangeListener;

import javafx.collections.ObservableList;

import javafx.event.Event;

import javafx.scene.Node;

import javafx.scene.control.Alert;

import javafx.scene.control.ButtonType;

import javafx.scene.control.Tab;

import javafx.scene.control.TabPane;

import javafx.stage.FileChooser;

import javafx.stage.FileChooser.ExtensionFilter;

import javafx.stage.Window;

import java.io.File;

import java.nio.file.Path;

import java.util.ArrayList;

import java.util.List;

import java.util.Optional;

import java.util.concurrent.atomic.AtomicReference;

import java.util.prefs.Preferences;

import java.util.stream.Collectors;

import static com.scrivenvar.Constants.GLOB_PREFIX_FILE;

import static com.scrivenvar.FileType.*;

import static com.scrivenvar.Messages.get;

import static com.scrivenvar.service.events.Notifier.YES;

/**

 * Tab pane for file editors.

 */

public final class FileEditorTabPane extends TabPane {

  private final static String FILTER_EXTENSION_TITLES =

      "Dialog.file.choose.filter";

  private final static Options sOptions = Services.load( Options.class );

  private final static Settings sSettings = Services.load( Settings.class );

  private final static Notifier sNotifier = Services.load( Notifier.class );

  private final ReadOnlyObjectWrapper<Path> mOpenDefinition =

      new ReadOnlyObjectWrapper<>();

  private final ReadOnlyObjectWrapper<FileEditorTab> mActiveFileEditor =

      new ReadOnlyObjectWrapper<>();

  private final ReadOnlyBooleanWrapper mAnyFileEditorModified =

      new ReadOnlyBooleanWrapper();

  private final ChangeListener<Integer> mCaretPositionListener;

  private final ChangeListener<Integer> mCaretParagraphListener;

  /**

   * Constructs a new file editor tab pane.

   *

   * @param caretPositionListener  Listens for changes to caret position so

   *                               that the status bar can update.

   * @param caretParagraphListener Listens for changes to the caret's paragraph

   *                               so that scrolling may occur.

   */

  public FileEditorTabPane(

      final ChangeListener<Integer> caretPositionListener,

      final ChangeListener<Integer> caretParagraphListener ) {

    final ObservableList<Tab> tabs = getTabs();

    setFocusTraversable( false );

    setTabClosingPolicy( TabClosingPolicy.ALL_TABS );

    addTabSelectionListener(

        ( tabPane, oldTab, newTab ) -> {

          if( newTab != null ) {

            mActiveFileEditor.set( (FileEditorTab) newTab );

          }

        }

    );

    final ChangeListener<Boolean> modifiedListener =

        ( observable, oldValue, newValue ) -> {

          for( final Tab tab : tabs ) {

            if( ((FileEditorTab) tab).isModified() ) {

              mAnyFileEditorModified.set( true );

              break;

            }

          }

        };

    tabs.addListener(

        (ListChangeListener<Tab>) change -> {

          while( change.next() ) {

            if( change.wasAdded() ) {

              change.getAddedSubList().forEach(

                  ( tab ) -> {

                    final var fet = (FileEditorTab) tab;

                    fet.modifiedProperty()

                       .addListener( modifiedListener );

                  } );

            }

            else if( change.wasRemoved() ) {

              change.getRemoved().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 );

        }

    );

    mCaretPositionListener = caretPositionListener;

    mCaretParagraphListener = caretParagraphListener;

  }

  /**

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

  }

  /**

   * Returns the tab that has keyboard focus.

   *

   * @return A non-null instance.

   */

  public FileEditorTab getActiveFileEditor() {

    return mActiveFileEditor.get();

  }

  /**

   * Returns the property corresponding to the tab that has focus.

   *

   * @return A non-null instance.

   */

  public ReadOnlyObjectProperty<FileEditorTab> activeFileEditorProperty() {

    return mActiveFileEditor.getReadOnlyProperty();

  }

  /**

   * Property that can answer whether the text has been modified.

   *

   * @return A non-null instance, true meaning the content has not been saved.

   */

  ReadOnlyBooleanProperty anyFileEditorModifiedProperty() {

    return mAnyFileEditorModified.getReadOnlyProperty();

  }

  /**

   * Creates a new editor instance from the given path.

   *

   * @param path The file to open.

   * @return A non-null instance.

   */

  private FileEditorTab createFileEditor( final Path path ) {

    assert path != null;

    final FileEditorTab tab = new FileEditorTab( path );

    tab.setOnCloseRequest( e -> {

      if( !canCloseEditor( tab ) ) {

        e.consume();

      }

      else if( isActiveFileEditor( tab ) ) {

        // Prevent prompting the user to save when there are no file editor

        // tabs open.

        mActiveFileEditor.set( null );

      }

    } );

    tab.addCaretPositionListener( mCaretPositionListener );

    tab.addCaretParagraphListener( mCaretParagraphListener );

    return tab;

  }

  private boolean isActiveFileEditor( final FileEditorTab tab ) {

    return getActiveFileEditor() == tab;

  }

  private Path getDefaultPath() {

    final String filename = getDefaultFilename();

    return (new File( filename )).toPath();

  }

  private String getDefaultFilename() {

    return getSettings().getSetting( "file.default", "untitled.md" );

  }

  /**

   * Called to add a new {@link FileEditorTab} to the tab pane.

   */

  void newEditor() {

    final FileEditorTab tab = createFileEditor( getDefaultPath() );

    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.

   */

  private void openFiles( final List<File> files ) {

    final List<String> extensions =

        createExtensionFilter( DEFINITION ).getExtensions();

    final FileTypePredicate predicate =

        new FileTypePredicate( extensions );

    // 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.isEmpty() ) {

      saveLastDirectory( editors.get( 0 ) );

    }

    editors.removeAll( definitions );

    // Open editor-friendly files (e.g,. Markdown, XML) in new tabs.

    if( !editors.isEmpty() ) {

      openEditors( editors, 0 );

    }

    if( !definitions.isEmpty() ) {

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

  }

  /**

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

  }

  /**

   * Called when the contents of the editor are to be saved.

   *

   * @param tab The tab containing content to save.

   * @return true The contents were saved (or needn't be saved).

   */

  public boolean saveEditor( final FileEditorTab tab ) {

    if( tab == null || !tab.isModified() ) {

      return true;

    }

    return tab.getPath() == null ? saveEditorAs( tab ) : tab.save();

  }

  /**

   * Opens the Save As dialog for the user to save the content under a new

   * path.

   *

   * @param tab The tab with contents to save.

   * @return true The contents were saved, or the tab was null.

   */

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

  }

  void saveAllEditors() {

    for( final FileEditorTab fileEditor : getAllEditors() ) {

      saveEditor( fileEditor );

    }

  }

  /**

   * Answers whether the file has had modifications. '

   *

   * @param tab THe tab to check for modifications.

   * @return false The file is unmodified.

   */

  @SuppressWarnings("BooleanMethodIsAlwaysInverted")

  boolean canCloseEditor( final FileEditorTab tab ) {

    final AtomicReference<Boolean> canClose = new AtomicReference<>();

    canClose.set( true );

    if( tab.isModified() ) {

      final Notification message = getNotifyService().createNotification(

          Messages.get( "Alert.file.close.title" ),

          Messages.get( "Alert.file.close.text" ),

          tab.getText()

      );

      final Alert confirmSave = getNotifyService().createConfirmation(

          getWindow(), message );

      final Optional<ButtonType> buttonType = confirmSave.showAndWait();

      buttonType.ifPresent(

          save -> canClose.set(

              save == YES ? saveEditor( tab ) : save == ButtonType.NO

          )

      );

    }

    return canClose.get();

  }

  boolean closeEditor( final FileEditorTab tab, final boolean save ) {

    if( tab == null ) {

      return true;

    }

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

    list.add( createExtensionFilter( SOURCE ) );

    list.add( createExtensionFilter( DEFINITION ) );

    list.add( createExtensionFilter( XML ) );

    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 void saveLastDirectory( final File file ) {

    getPreferences().put( "lastDirectory", file.getParent() );

  }

  public void initPreferences() {

    int activeIndex = 0;

    final Preferences preferences = getPreferences();

    final String[] fileNames = Utils.getPrefsStrings( preferences, "file" );

    final String activeFileName = preferences.get( "activeFile", null );

    final List<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[ 0 ] ) );

    final FileEditorTab activeEditor = getActiveFileEditor();

    final Path filePath = activeEditor == null ? null : activeEditor.getPath();

    if( filePath == null ) {

      preferences.remove( "activeFile" );

    }

    else {

      preferences.put( "activeFile", filePath.toString() );

    }

  }

  private List<String> getExtensions( final String key ) {

    return getSettings().getStringSettingList( key );

  }

  private Notifier getNotifyService() {

    return sNotifier;

  }

  private Settings getSettings() {

    return sSettings;

import static java.awt.font.TextAttribute.LIGATURES;

import static java.awt.font.TextAttribute.LIGATURES_ON;

    // After the stage is visible, the panel dimensions are known, which

    // allows scaling images to fit the preview panel.

  private static void initFonts() {

    final var ge = GraphicsEnvironment.getLocalGraphicsEnvironment();

      event -> {

        rerender();

      };

  /**

   * Called when the definition data is changed.

   */

  private final EventHandler<TreeItem.TreeModificationEvent<Event>>

      mTreeHandler = event -> {

    exportDefinitions( getDefinitionPath() );

    interpolateResolvedMap();

    rerender();

  };

  /**

   * Called to switch to the definition pane when the user presses the TAB key.

   */

  private final EventHandler<? super KeyEvent> mTabKeyHandler =

      (EventHandler<KeyEvent>) event -> {

        if( event.getCode() == TAB ) {

          getDefinitionPane().requestFocus();

          event.consume();

        }

      };

  /**

   * Called to inject the selected item when the user presses ENTER in the

   * definition pane.

   */

  private final EventHandler<? super KeyEvent> mDefinitionKeyHandler =

      event -> {

        if( event.getCode() == ENTER ) {

          getVariableNameInjector().injectSelectedItem();

        }

      };

  private final ChangeListener<Integer> mCaretPositionListener =

      ( observable, oldPosition, newPosition ) -> {

        final FileEditorTab tab = getActiveFileEditorTab();

        final EditorPane pane = tab.getEditorPane();

        final StyleClassedTextArea editor = pane.getEditor();

        getLineNumberText().setText(

            get( STATUS_BAR_LINE,

                 editor.getCurrentParagraph() + 1,

                 editor.getParagraphs().size(),

                 editor.getCaretPosition()

            )

        );

      };

  private final ChangeListener<Integer> mCaretParagraphListener =

      ( observable, oldIndex, newIndex ) ->

          scrollToParagraph( newIndex, true );

  private DefinitionSource mDefinitionSource = createDefaultDefinitionSource();

  private final DefinitionPane mDefinitionPane = new DefinitionPane();

  private final HTMLPreviewPane mPreviewPane = createHTMLPreviewPane();

  private final FileEditorTabPane mFileEditorPane = new FileEditorTabPane(

      mCaretPositionListener,

      mCaretParagraphListener );

  /**

   * Listens on the definition pane for double-click events.

   */

  private final VariableNameInjector mVariableNameInjector

      = new VariableNameInjector( mDefinitionPane );

  public MainWindow() {

    sNotifier.addObserver( this );

    mStatusBar = createStatusBar();

    mLineNumberText = createLineNumberText();

    mFindTextField = createFindTextField();

    mScene = createScene();

    mSpellChecker = createSpellChecker();

    // Add the close request listener before the window is shown.

    initLayout();