Dave Jarvis' Repositories

- Bug fixes synchronized scrolling

- Added generic CARETPOSITION into document to scroll preview pane

  * Apache Tika Team: [Apache Tika](https://tika.apache.org/)

  public static final String BUNDLE_NAME = "com.scrivenvar.messages";

  public static final String STYLESHEET_PREVIEW = "com/scrivenvar/scene.css";

  public static final String STYLESHEET_EDITOR = "com/scrivenvar/editor/Markdown.css";

  public static final String LOGO_32 = "com/scrivenvar/logo32.png";

  public static final String LOGO_16 = "com/scrivenvar/logo16.png";

  public static final String LOGO_128 = "com/scrivenvar/logo128.png";

  public static final String LOGO_256 = "com/scrivenvar/logo256.png";

  public static final String LOGO_512 = "com/scrivenvar/logo512.png";

  /**

   * Separates YAML variable nodes (e.g., the dots in <code>$root.node.var$</code>).

   */

  public static final String SEPARATOR = ".";

  public static final String CARET_POSITION = "CARETPOSITION";

  public static final String MD_CARET_POSITION = "${" + CARET_POSITION + "}";

  public static final String XML_CARET_POSITION = "<![CDATA[" + MD_CARET_POSITION + "]]>";

import com.scrivenvar.editor.EditorPane;

import com.scrivenvar.editor.MarkdownEditorPane;

import com.scrivenvar.service.Options;

import com.scrivenvar.service.events.AlertMessage;

import com.scrivenvar.service.events.AlertService;

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.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 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 Options options = Services.load( Options.class );

  private final AlertService alertService = Services.load( AlertService.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 );

    setUserData( this );

    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 (filePath == null)

      ? null

      : new Tooltip( 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 (*must* 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() );

  }

  /**

   * 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 getEditorPane().getEditor().getCaretPosition();

  }

  /**

   * 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( Exception ex ) {

        alert(

          "FileEditor.loadFailed.title", "FileEditor.loadFailed.message", 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( 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 AlertService service = getAlertService();

    final AlertMessage message = service.createAlertMessage(

      Messages.get( titleKey ),

      Messages.get( messageKey ),

      getPath(),

      e.getMessage()

    );

    service.createAlertError( message ).showAndWait();

    return false;

  }

  /**

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

  }

  Path getPath() {

    return this.path;

  }

  void setPath( final Path path ) {

    this.path = path;

  }

  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 paragraph change events.

   *

   * @param listener The listener to notify when the caret changes paragraphs.

   */

  public void addCaretParagraphListener( final ChangeListener<Integer> listener){

    getEditorPane().addCaretParagraphListener( listener );

  }

  /**

   * Delegates 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.

   */

  protected EditorPane getEditorPane() {

    if( this.editorPane == null ) {

      this.editorPane = new MarkdownEditorPane();

    }

    return this.editorPane;

  }

  private AlertService getAlertService() {

    return this.alertService;

  }

  private Options getOptions() {

    return this.options;

  }

  private Charset getEncoding() {

    return this.encoding;

  }

  private void setEncoding( final Charset encoding ) {

    this.encoding = encoding;

import static com.scrivenvar.Messages.get;

import com.scrivenvar.predicates.files.FileTypePredicate;

import com.scrivenvar.service.Options;

import com.scrivenvar.service.Settings;

import com.scrivenvar.service.events.AlertMessage;

import com.scrivenvar.service.events.AlertService;

import static com.scrivenvar.service.events.AlertService.NO;

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

import com.scrivenvar.util.Utils;

import java.io.File;

import java.nio.file.Path;

import java.util.ArrayList;

import java.util.List;

import java.util.function.Consumer;

import java.util.prefs.Preferences;

import java.util.stream.Collectors;

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.beans.value.ObservableValue;

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.scene.control.TabPane.TabClosingPolicy;

import javafx.scene.input.InputEvent;

import javafx.stage.FileChooser;

import javafx.stage.FileChooser.ExtensionFilter;

import javafx.stage.Window;

import org.fxmisc.richtext.StyledTextArea;

import org.fxmisc.wellbehaved.event.EventPattern;

import org.fxmisc.wellbehaved.event.InputMap;

/**

 * Tab pane for file editors.

 *

 * @author Karl Tauber and White Magic Software, Ltd.

 */

public final class FileEditorTabPane extends TabPane {

  private final static String FILTER_PREFIX = "Dialog.file.choose.filter";

  private final Options options = Services.load( Options.class );

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

  private final AlertService alertService = Services.load( AlertService.class );

  private final ReadOnlyObjectWrapper<FileEditorTab> activeFileEditor = new ReadOnlyObjectWrapper<>();

  private final ReadOnlyBooleanWrapper anyFileEditorModified = new ReadOnlyBooleanWrapper();

  public FileEditorTabPane() {

    final ObservableList<Tab> tabs = getTabs();

    setFocusTraversable( false );

    setTabClosingPolicy( TabClosingPolicy.ALL_TABS );

    addTabChangeListener( (ObservableValue<? extends Tab> tabPane,

      final Tab oldTab, final Tab newTab) -> {

      if( newTab != null ) {

        activeFileEditor.set( (FileEditorTab)newTab.getUserData() );

      }

    } );

    final ChangeListener<Boolean> modifiedListener = (observable, oldValue, newValue) -> {

      for( final Tab tab : tabs ) {

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

          this.anyFileEditorModified.set( true );

          break;

        }

      }

    };

    tabs.addListener( (ListChangeListener<Tab>)change -> {

      while( change.next() ) {

        if( change.wasAdded() ) {

          change.getAddedSubList().stream().forEach( (tab) -> {

            ((FileEditorTab)tab.getUserData()).modifiedProperty().addListener( modifiedListener );

          } );

        } else if( change.wasRemoved() ) {

          change.getRemoved().stream().forEach( (tab) -> {

            ((FileEditorTab)tab.getUserData()).modifiedProperty().removeListener( modifiedListener );

          } );

        }

      }

      // Changes in the tabs may also change anyFileEditorModified property

      // (e.g. closed modified file)

      modifiedListener.changed( null, null, null );

    } );

  }

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

  }

  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;

  }

  Node getNode() {

    return this;

  }

  /**

   * Called when the user selects New from the File menu.

   *

   * @return The newly added tab.

   */

  FileEditorTab newEditor() {

    final FileEditorTab tab = createFileEditor( null );

    getTabs().add( tab );

    getSelectionModel().select( tab );

    return tab;

  }

  List<FileEditorTab> openFileDialog() {

    final FileChooser dialog

      = createFileChooser( get( "Dialog.file.choose.open.title" ) );

    final List<File> files = dialog.showOpenMultipleDialog( getWindow() );

    return (files != null && !files.isEmpty())

      ? openFiles( files )

      : new ArrayList<>();

  }

  /**

   * 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 List<FileEditorTab> openFiles( final List<File> files ) {

    final List<FileEditorTab> openedEditors = new ArrayList<>();

    final FileTypePredicate predicate

      = new FileTypePredicate( createExtensionFilter( "definition" ).getExtensions() );

    // The user might have opened muliple 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 );

    editors.removeAll( definitions );

    // If there are any editor-friendly files opened (e.g,. Markdown, XML), then

    // open them up in new tabs.

    if( editors.size() > 0 ) {

      saveLastDirectory( editors.get( 0 ) );

      openedEditors.addAll( openEditors( editors, 0 ) );

    }

    if( definitions.size() > 0 ) {

      openDefinition( definitions.get( 0 ) );

    }

    return openedEditors;

  }

  private List<FileEditorTab> openEditors( final List<File> files, final int activeIndex ) {

    final int fileTally = files.size();

    final List<FileEditorTab> editors = new ArrayList<>( fileTally );

    final List<Tab> tabs = getTabs();

    // Close single unmodified "Untitled" tab.

    if( tabs.size() == 1 ) {

      final FileEditorTab fileEditor = (FileEditorTab)(tabs.get( 0 ).getUserData());

      if( fileEditor.getPath() == null && !fileEditor.isModified() ) {

        closeEditor( fileEditor, false );

      }

    }

    for( int i = 0; i < fileTally; i++ ) {

      final Path path = files.get( i ).toPath();

      // Check whether file is already opened.

      FileEditorTab fileEditor = findEditor( path );

      if( fileEditor == null ) {

        fileEditor = createFileEditor( path );

        getTabs().add( fileEditor );

        editors.add( fileEditor );

      }

      // Select first file.

      if( i == activeIndex ) {

        getSelectionModel().select( fileEditor );

      }

    }

    return editors;

  }

  /**

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

    System.out.println( "open definition file: " + definition.toString() );

  }

  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;

  }

  boolean canCloseEditor( final FileEditorTab tab ) {

    if( !tab.isModified() ) {

      return true;

    }

    final AlertMessage message = getAlertService().createAlertMessage(

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

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

      tab.getText()

    );

    final Alert alert = getAlertService().createAlertConfirmation( message );

    final ButtonType response = alert.showAndWait().get();

    return response == YES ? saveEditor( tab ) : response == NO;

  }

  private AlertService getAlertService() {

    return this.alertService;

  }

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

    }

    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 = getState().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;

  }

  private ExtensionFilter createExtensionFilter( final String filetype ) {

    final String tKey = String.format( "%s.title.%s", FILTER_PREFIX, filetype );

    final String eKey = String.format( "%s.ext.%s", FILTER_PREFIX, filetype );

    return new ExtensionFilter( Messages.get( tKey ), getExtensions( eKey ) );

  }

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

    return getStringSettingList( key );

  }

  private List<String> getStringSettingList( String key ) {

    return getStringSettingList( key, null );

  }

  private List<String> getStringSettingList( String key, List<String> values ) {

    return getSettings().getStringSettingList( key, values );

  }

  private void saveLastDirectory( final File file ) {

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

  }

  public void restorePreferences() {

    int activeIndex = 0;

    final Preferences preferences = getState();

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

      return;

    }

    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;

      if( fileEditor.getPath() != null ) {

        fileNames.add( fileEditor.getPath().toString() );

      }

    }

    final Preferences preferences = getState();

    Utils.putPrefsStrings( preferences, "file", fileNames.toArray( new String[ fileNames.size() ] ) );

    final FileEditorTab activeEditor = getActiveFileEditor();

    if( activeEditor != null && activeEditor.getPath() != null ) {

      preferences.put( "activeFile", activeEditor.getPath().toString() );

    } else {

      preferences.remove( "activeFile" );

    }

  }

  private Settings getSettings() {

    return this.settings;

  }

  protected Options getOptions() {

    return this.options;

  }

  private Window getWindow() {

    return getScene().getWindow();

  }

  protected Preferences getState() {

    return getOptions().getState();