Dave Jarvis' Repositories

*.bin

*.exe

    java -jar build/libs/keenwrite.jar

    java -jar build\libs\keenwrite.jar

Copyright 2020 White Magic Software, Ltd.

# ![Logo](docs/images/app-title.png)

* [Windows](https://gitreleases.dev/gh/DaveJarvis/keenwrite/latest/keenwrite.exe)

* [Linux](https://gitreleases.dev/gh/DaveJarvis/keenwrite/latest/keenwrite.bin)

* [Java Archive](https://gitreleases.dev/gh/DaveJarvis/keenwrite/latest/keenwrite.jar)

    C:\Users\%USERNAME%\AppData\Local\warp\packages\keenwrite.exe

On Linux, run `chmod +x keenwrite.bin` then `./keenwrite.bin`.

On other platforms, download and install a full version of [OpenJDK 14](https://bell-sw.com/pages/downloads/?version=java-14#mn) that includes JavaFX module support, then run:

java -jar keenwrite.jar

## Screenshot

def resourceDir = sourceSets.main.resources.srcDirs[0]

def config = new Properties()

file("${resourceDir}/bootstrap.properties").withInputStream {

  config.load(it)

}

  applicationName = config["application.title"].toLowerCase()

def propertiesFile = new File("${resourceDir}/com/${applicationName}/app.properties")

# ![Logo](images/app-title.png)

Interpolated variables within R calculations, formatted as an equation:

$\sqrt{`r#x( v$formula$sqrt$value)`} = \pm `r# round(sqrt(x( v$formula$sqrt$value )),5)`$

    value: "42"

"%SCRIPT_DIR%\\${ARG_JAVA_DIR}\\bin\\java" -jar "%SCRIPT_DIR%\\${APP_NAME}.jar" %*

/*

 * Copyright 2020 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.keenwrite;

import com.keenwrite.service.Settings;

import com.keenwrite.util.ProtocolScheme;

import java.nio.file.Path;

import static com.keenwrite.Constants.GLOB_PREFIX_FILE;

import static com.keenwrite.Constants.SETTINGS;

import static com.keenwrite.FileType.UNKNOWN;

import static com.keenwrite.predicates.PredicateFactory.createFileTypePredicate;

import static java.lang.String.format;

/**

 * Provides common behaviours for factories that instantiate classes based on

 * file type.

 */

public class AbstractFileFactory {

  private static final String MSG_UNKNOWN_FILE_TYPE =

      "Unknown type '%s' for file '%s'.";

  /**

   * Determines the file type from the path extension. This should only be

   * called when it is known that the file type won't be a definition file

   * (e.g., YAML or other definition source), but rather an editable file

   * (e.g., Markdown, XML, etc.).

   *

   * @param path The path with a file name extension.

   * @return The FileType for the given path.

   */

  public FileType lookup( final Path path ) {

    return lookup( path, GLOB_PREFIX_FILE );

  }

  /**

   * Creates a file type that corresponds to the given path.

   *

   * @param path   Reference to a variable definition file.

   * @param prefix One of GLOB_PREFIX_DEFINITION or GLOB_PREFIX_FILE.

   * @return The file type that corresponds to the given path.

   */

  protected FileType lookup( final Path path, final String prefix ) {

    assert path != null;

    assert prefix != null;

    final var settings = getSettings();

    final var keys = settings.getKeys( prefix );

    var found = false;

    var fileType = UNKNOWN;

    while( keys.hasNext() && !found ) {

      final var key = keys.next();

      final var patterns = settings.getStringSettingList( key );

      final var predicate = createFileTypePredicate( patterns );

      if( found = predicate.test( path.toFile() ) ) {

        // Remove the EXTENSIONS_PREFIX to get the filename extension mapped

        // to a standard name (as defined in the settings.properties file).

        final String suffix = key.replace( prefix + ".", "" );

        fileType = FileType.from( suffix );

      }

    }

    return fileType;

  }

  /**

   * Throws IllegalArgumentException because the given path could not be

   * recognized. This exists because

   *

   * @param type The detected path type (protocol, file extension, etc.).

   * @param path The path to a source of definitions.

   */

  protected void unknownFileType(

      final ProtocolScheme type, final String path ) {

    final String msg = format( MSG_UNKNOWN_FILE_TYPE, type, path );

    throw new IllegalArgumentException( msg );

  }

  /**

   * Return the singleton Settings instance.

   *

   * @return A non-null instance.

   */

  private Settings getSettings() {

    return SETTINGS;

  }

}

/*

 * Copyright 2020 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.keenwrite;

import java.io.IOException;

import java.util.Properties;

/**

 * Responsible for loading the bootstrap.properties file, which is

 * tactically located outside of the standard resource reverse domain name

 * namespace to avoid hard-coding the application name in many places.

 * Instead, the application name is located in the bootstrap file, which is

 * then used to look-up the remaining settings.

 * <p>

 * See {@link Constants#PATH_PROPERTIES_SETTINGS} for details.

 * </p>

 */

public class Bootstrap {

  private static final Properties BOOTSTRAP = new Properties();

  static {

    try( final var stream =

             Constants.class.getResourceAsStream( "/bootstrap.properties" ) ) {

      BOOTSTRAP.load( stream );

    } catch( final IOException ignored ) {

      // Bootstrap properties cannot be found, throw in the towel.

    }

  }

  public static final String APP_TITLE =

      BOOTSTRAP.getProperty( "application.title" );

  public static final String APP_TITLE_LOWERCASE = APP_TITLE.toLowerCase();

}

/*

 * Copyright 2020 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.keenwrite;

import com.keenwrite.service.Settings;

import javafx.scene.image.Image;

import java.nio.file.Path;

import java.nio.file.Paths;

import static com.keenwrite.Bootstrap.APP_TITLE_LOWERCASE;

import static java.lang.String.format;

/**

 * Defines application-wide default values.

 */

public class Constants {

  /**

   * Used by the default settings to load the {@link Settings} service. This

   * must come before any attempt is made to create a {@link Settings} object.

   * The reference to {@link Bootstrap#APP_TITLE_LOWERCASE} should cause the

   * JVM to load {@link Bootstrap} prior to proceeding. Loading that class

   * beforehand will read the bootstrap properties file to determine the

   * application name, which is then used to locate the settings properties.

   */

  public static final String PATH_PROPERTIES_SETTINGS =

      format( "/com/%s/settings.properties", APP_TITLE_LOWERCASE );

  /**

   * The {@link Settings} uses {@link #PATH_PROPERTIES_SETTINGS}.

   */

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

  public static final String DEFINITION_NAME = "variables.yaml";

  public static final String APP_BUNDLE_NAME = get( "application.messages" );

  // Prevent double events when updating files on Linux (save and timestamp).

  public static final int APP_WATCHDOG_TIMEOUT = get(

      "application.watchdog.timeout", 200 );

  public static final String STYLESHEET_SCENE = get( "file.stylesheet.scene" );

  public static final String STYLESHEET_MARKDOWN = get(

      "file.stylesheet.markdown" );

  public static final String STYLESHEET_PREVIEW = get(

      "file.stylesheet.preview" );

  public static final String FILE_LOGO_16 = get( "file.logo.16" );

  public static final String FILE_LOGO_32 = get( "file.logo.32" );

  public static final String FILE_LOGO_128 = get( "file.logo.128" );

  public static final String FILE_LOGO_256 = get( "file.logo.256" );

  public static final String FILE_LOGO_512 = get( "file.logo.512" );

  public static final Image ICON_DIALOG = new Image( FILE_LOGO_32 );

  public static final String PREFS_ROOT = get( "preferences.root" );

  public static final String PREFS_STATE = get( "preferences.root.state" );

  /**

   * Refer to filename extension settings in the configuration file. Do not

   * terminate these prefixes with a period.

   */

  public static final String GLOB_PREFIX_FILE = "file.ext";

  public static final String GLOB_PREFIX_DEFINITION =

      "definition." + GLOB_PREFIX_FILE;

  /**

   * Three parameters: line number, column number, and offset.

   */

  public static final String STATUS_BAR_LINE = "Main.status.line";

  public static final String STATUS_BAR_OK = "Main.status.state.default";

  /**

   * Used to show an error while parsing, usually syntactical.

   */

  public static final String STATUS_PARSE_ERROR = "Main.status.error.parse";

  public static final String STATUS_DEFINITION_BLANK =

      "Main.status.error.def.blank";

  public static final String STATUS_DEFINITION_EMPTY =

      "Main.status.error.def.empty";

  /**

   * One parameter: the word under the cursor that could not be found.

   */

  public static final String STATUS_DEFINITION_MISSING =

      "Main.status.error.def.missing";

  /**

   * Used when creating flat maps relating to resolved variables.

   */

  public static final int DEFAULT_MAP_SIZE = 64;

  /**

   * Default image extension order to use when scanning.

   */

  public static final String PERSIST_IMAGES_DEFAULT =

      get( "file.ext.image.order" );

  /**

   * Default working directory to use for R startup script.

   */

  public static final String USER_DIRECTORY = System.getProperty( "user.dir" );

  /**

   * Default path to use for an untitled (pathless) file.

   */

  public static final Path DEFAULT_DIRECTORY = Paths.get( USER_DIRECTORY );

  /**

   * Default starting delimiter for definition variables.

   */

  public static final String DEF_DELIM_BEGAN_DEFAULT = "${";

  /**

   * Default ending delimiter for definition variables.

   */

  public static final String DEF_DELIM_ENDED_DEFAULT = "}";

  /**

   * Default starting delimiter when inserting R variables.

   */

  public static final String R_DELIM_BEGAN_DEFAULT = "x( ";

  /**

   * Default ending delimiter when inserting R variables.

   */

  public static final String R_DELIM_ENDED_DEFAULT = " )";

  /**

   * Resource directory where different language lexicons are located.

   */

  public static final String LEXICONS_DIRECTORY = "lexicons";

  /**

   * Used as the prefix for uniquely identifying HTML block elements, which

   * helps coordinate scrolling the preview pane to where the user is typing.

   */

  public static final String PARAGRAPH_ID_PREFIX = "p-";

  /**

   * Absolute location of true type font files within the Java archive file.

   */

  public static final String FONT_DIRECTORY = "/fonts";

  /**

   * Default text editor font size, in points.

   */

  public static final float FONT_SIZE_EDITOR = 12f;

  /**

   * Prevent instantiation.

   */

  private Constants() {

  }

  private static String get( final String key ) {

    return SETTINGS.getSetting( key, "" );

  }

  @SuppressWarnings("SameParameterValue")

  private static int get( final String key, final int defaultValue ) {

    return SETTINGS.getSetting( key, defaultValue );

  }

}

/*

 * Copyright 2020 Karl Tauber and White Magic Software, Ltd.

 *

 * 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.keenwrite;

import com.keenwrite.editors.EditorPane;

import com.keenwrite.editors.markdown.MarkdownEditorPane;

import com.keenwrite.service.events.Notification;

import com.keenwrite.service.events.Notifier;

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.event.EventHandler;

import javafx.event.EventType;

import javafx.scene.Scene;

import javafx.scene.control.Tab;

import javafx.scene.control.Tooltip;

import javafx.scene.text.Text;

import javafx.stage.Window;

import org.fxmisc.flowless.VirtualizedScrollPane;

import org.fxmisc.richtext.StyleClassedTextArea;

import org.fxmisc.undo.UndoManager;

import org.jetbrains.annotations.NotNull;

import org.mozilla.universalchardet.UniversalDetector;

import java.io.File;

import java.nio.charset.Charset;

import java.nio.file.Files;

import java.nio.file.Path;

import static com.keenwrite.Messages.get;

import static com.keenwrite.StatusBarNotifier.alert;

import static com.keenwrite.StatusBarNotifier.getNotifier;

import static java.nio.charset.StandardCharsets.UTF_8;

import static java.util.Locale.ENGLISH;

import static javafx.application.Platform.runLater;

/**

 * Editor for a single file.

 */

public final class FileEditorTab extends Tab {

  private final MarkdownEditorPane mEditorPane = new MarkdownEditorPane();

  private final ReadOnlyBooleanWrapper mModified = new ReadOnlyBooleanWrapper();

  private final BooleanProperty canUndo = new SimpleBooleanProperty();

  private final BooleanProperty canRedo = new SimpleBooleanProperty();

  /**

   * Character encoding used by the file (or default encoding if none found).

   */

  private Charset mEncoding = UTF_8;

  /**

   * File to load into the editor.

   */

  private Path mPath;

  public FileEditorTab( final Path path ) {

    setPath( path );

    mModified.addListener( ( observable, oldPath, newPath ) -> updateTab() );

    setOnSelectionChanged( e -> {

      if( isSelected() ) {

        runLater( this::activated );

        requestFocus();

      }

    } );

  }

  private void updateTab() {

    setText( getTabTitle() );

    setGraphic( getModifiedMark() );

    setTooltip( getTabTooltip() );

  }

  /**

   * Returns the base filename (without the directory names).

   *

   * @return The untitled text if the path hasn't been set.

   */

  private String getTabTitle() {

    return getPath().getFileName().toString();

  }

  /**

   * Returns the full filename represented by the path.

   *

   * @return The untitled text if the path hasn't been set.

   */

  private Tooltip getTabTooltip() {

    final Path filePath = getPath();

    return new Tooltip( filePath == null ? "" : filePath.toString() );

  }

  /**

   * Returns a marker to indicate whether the file has been modified.

   *

   * @return "*" when the file has changed; otherwise null.

   */

  private Text getModifiedMark() {

    return isModified() ? new Text( "*" ) : null;

  }

  /**

   * Called when the user switches tab.

   */

  private void activated() {

    // Tab is closed or no longer active.

    if( getTabPane() == null || !isSelected() ) {

      return;

    }

    // If the tab is devoid of content, load it.

    if( getContent() == null ) {

      readFile();

      initLayout();

      initUndoManager();

    }

  }

  private void initLayout() {

    setContent( getScrollPane() );

  }

  /**

   * Tracks undo requests, but can only be called <em>after</em> load.

   */

  private void initUndoManager() {

    final UndoManager<?> undoManager = getUndoManager();

    undoManager.forgetHistory();

    // Bind the editor undo manager to the properties.

    mModified.bind( Bindings.not( undoManager.atMarkedPositionProperty() ) );

    canUndo.bind( undoManager.undoAvailableProperty() );

    canRedo.bind( undoManager.redoAvailableProperty() );

  }

  private void requestFocus() {

    getEditorPane().requestFocus();

  }

  /**

   * Searches from the caret position forward for the given string.

   *

   * @param needle The text string to match.

   */

  public void searchNext( final String needle ) {

    final String haystack = getEditorText();

    int index = haystack.indexOf( needle, getCaretPosition() );

    // Wrap around.

    if( index == -1 ) {

      index = haystack.indexOf( needle );

    }

    if( index >= 0 ) {

      setCaretPosition( index );

      getEditor().selectRange( index, index + needle.length() );

    }

  }

  /**

   * Gets a reference to the scroll pane that houses the editor.

   *

   * @return The editor's scroll pane, containing a vertical scrollbar.

   */

  public VirtualizedScrollPane<StyleClassedTextArea> getScrollPane() {

    return getEditorPane().getScrollPane();

  }

  /**

   * 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 text area associated with this tab.

   *

   * @return A text editor.

   */

  private StyleClassedTextArea getEditor() {

    return getEditorPane().getEditor();

  }

  /**

   * Returns true if the given path exactly matches this tab's path.

   *

   * @param check The path to compare against.

   * @return true The paths are the same.

   */

  public boolean isPath( final Path check ) {

    final Path filePath = getPath();

    return filePath != null && filePath.equals( check );

  }

  /**

   * Reads the entire file contents from the path associated with this tab.

   */

  private void readFile() {

    final Path path = getPath();

    final File file = path.toFile();

    try {

      if( file.exists() ) {

        if( file.canWrite() && file.canRead() ) {

          final EditorPane pane = getEditorPane();

          pane.setText( asString( Files.readAllBytes( path ) ) );

          pane.scrollToTop();

        }

        else {

          final String msg = get( "FileEditor.loadFailed.reason.permissions" );

          alert( "FileEditor.loadFailed.message", file.toString(), msg );

        }

      }

    } catch( final Exception ex ) {

      alert( ex );

    }

  }

  /**

   * Saves the entire file contents from the path associated with this tab.

   *

   * @return true The file has been saved.

   */

  public boolean save() {

    try {

      final EditorPane editor = getEditorPane();

      Files.write( getPath(), asBytes( editor.getText() ) );

      editor.getUndoManager().mark();

      return true;

    } catch( final Exception ex ) {

      return popupAlert(

          "FileEditor.saveFailed.title",

          "FileEditor.saveFailed.message",

          ex

      );

    }

  }

  /**

   * Creates an alert dialog and waits for it to close.

   *

   * @param titleKey   Resource bundle key for the alert dialog title.

   * @param messageKey Resource bundle key for the alert dialog message.

   * @param e          The unexpected happening.

   * @return false

   */

  @SuppressWarnings("SameParameterValue")

  private boolean popupAlert(

      final String titleKey, final String messageKey, final Exception e ) {

    final Notifier service = getNotifier();

    final Path filePath = getPath();

    final Notification message = service.createNotification(

        get( titleKey ),

        get( messageKey ),

        filePath == null ? "" : filePath,

        e.getMessage()

    );

    try {

      service.createError( getWindow(), message ).showAndWait();

    } catch( final Exception ex ) {

      alert( ex );

    }

    return false;

  }

  private Window getWindow() {

    final Scene scene = getEditorPane().getScene();

    if( scene == null ) {

      throw new UnsupportedOperationException( "No scene window available" );

    }

    return scene.getWindow();

  }

  /**

   * Returns a best guess at the file encoding. If the encoding could not be

   * detected, this will return the default charset for the JVM.

   *

   * @param bytes The bytes to perform character encoding detection.

   * @return The character encoding.

   */

  private Charset detectEncoding( final byte[] bytes ) {

    final var detector = new UniversalDetector( null );

    detector.handleData( bytes, 0, bytes.length );

    detector.dataEnd();

    final String charset = detector.getDetectedCharset();

    return charset == null

        ? Charset.defaultCharset()

        : Charset.forName( charset.toUpperCase( ENGLISH ) );

  }

  /**

   * Converts the given string to an array of bytes using the encoding that was

   * originally detected (if any) and associated with this file.

   *

   * @param text The text to convert into the original file encoding.

   * @return A series of bytes ready for writing to a file.

   */

  private byte[] asBytes( final String text ) {

    return text.getBytes( getEncoding() );

  }

  /**

   * Converts the given bytes into a Java String. This will call setEncoding

   * with the encoding detected by the CharsetDetector.

   *

   * @param text The text of unknown character encoding.

   * @return The text, in its auto-detected encoding, as a String.

   */

  private String asString( final byte[] text ) {

    setEncoding( detectEncoding( text ) );

    return new String( text, getEncoding() );

  }

  /**

   * Returns the path to the file being edited in this tab.

   *

   * @return A non-null instance.

   */

  public Path getPath() {

    return mPath;

  }

  /**

   * Sets the path to a file for editing and then updates the tab with the

   * file contents.

   *

   * @param path A non-null instance.

   */

  public void setPath( final Path path ) {

    assert path != null;

    mPath = path;

    updateTab();

  }

  public boolean isModified() {

    return mModified.get();

  }

  ReadOnlyBooleanProperty modifiedProperty() {

    return mModified.getReadOnlyProperty();

  }

  BooleanProperty canUndoProperty() {

    return this.canUndo;

  }

  BooleanProperty canRedoProperty() {

    return this.canRedo;

  }

  private UndoManager<?> getUndoManager() {

    return getEditorPane().getUndoManager();

  }

  /**

   * Forwards to the editor pane's listeners for text change events.

   *

   * @param listener The listener to notify when the text changes.

   */

  public void addTextChangeListener( final ChangeListener<String> listener ) {

    getEditorPane().addTextChangeListener( listener );

  }

  /**

   * Forwards to the editor pane's listeners for caret change events.

   *

   * @param listener Notified when the caret position changes.

   */

  public void addCaretPositionListener(

      final ChangeListener<? super Integer> listener ) {

    getEditorPane().addCaretPositionListener( listener );

  }

  /**

   * Forwards to the editor pane's listeners for paragraph index change events.

   *

   * @param listener Notified when the caret's paragraph index changes.

   */

  public void addCaretParagraphListener(

      final ChangeListener<? super Integer> listener ) {

    getEditorPane().addCaretParagraphListener( listener );

  }

  public <T extends Event> void addEventFilter(

      final EventType<T> eventType,

      final EventHandler<? super T> eventFilter ) {

    getEditor().addEventFilter( eventType, eventFilter );

  }

  /**

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

   */

  @NotNull

  public MarkdownEditorPane getEditorPane() {

    return mEditorPane;

  }

  /**

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

    return mEncoding;

  }

  private void setEncoding( final Charset encoding ) {

    assert encoding != null;

    mEncoding = encoding;

  }

  /**

   * Returns the tab title, without any modified indicators.

   *

   * @return The tab title.

   */

  @Override

  public String toString() {

    return getTabTitle();

  }

}

/*

 * Copyright 2020 Karl Tauber and 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.keenwrite;

import com.keenwrite.service.Options;

import com.keenwrite.service.Settings;

import com.keenwrite.service.events.Notification;

import com.keenwrite.service.events.Notifier;

import com.keenwrite.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.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.keenwrite.Constants.GLOB_PREFIX_FILE;

import static com.keenwrite.Constants.SETTINGS;

import static com.keenwrite.FileType.*;

import static com.keenwrite.Messages.get;

import static com.keenwrite.predicates.PredicateFactory.createFileTypePredicate;

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

/**

 * Tab pane for file editors.

 */

public final class FileEditorTabPane extends TabPane {

  private static final String FILTER_EXTENSION_TITLES =

      "Dialog.file.choose.filter";

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

  private static final 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 ) -> {

                    final var fet = (FileEditorTab) tab;

                    fet.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 var predicate = createFileTypePredicate( extensions );

    // The user might have opened multiple definitions files. These will

    // be discarded from the text editable files.

    final var definitions

        = files.stream().filter( predicate ).collect( Collectors.toList() );

    // Create a modifiable list to remove any definition files that were

    // opened.

    final var 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 var allEditors = getTabs();

    final List<String> fileNames = new ArrayList<>( allEditors.size() );