Dave Jarvis' Repositories

*.ods binary

bin/linux-x64.warp-packer binary

bin/osslsigncode binary

bin/warp-packer binary

scripts/rcedit-x64.exe binary

!src/main/java/com/keenwrite/processors/markdown/extensions/quotes

* [JDK 23](https://bell-sw.com/pages/downloads) (Full JDK + JavaFX)

* [Gradle 8.10.2](https://gradle.org/releases)

* [Git 2.46.2](https://git-scm.com/downloads)

# @param f The file name to convert.

# @param decimals Rounded decimal places (default 2).

  df <- read.table( f, sep=',', header=T, stringsAsFactors=F, check.names=F )

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

1. Download the *Full version* of the Java Runtime Environment, [JRE 23](https://bell-sw.com/pages/downloads).

MIT License

Copyright (c) 2018 Diego Giagio <diego@giagio.com>

Permission is hereby granted, free of charge, to any person obtaining a copy

of this software and associated documentation files (the "Software"), to deal

in the Software without restriction, including without limitation the rights

to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

copies of the Software, and to permit persons to whom the Software is

furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all

copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

SOFTWARE.

OpenSSL based Authenticode signing for PE/MSI/Java CAB files.

Copyright (C) 2005-2014 Per Allansson <pallansson@gmail.com>

Copyright (C) 2018-2022 Michał Trojnara <Michal.Trojnara@stunnel.org>

This program is free software: you can redistribute it and/or modify

it under the terms of the GNU General Public License as published by

the Free Software Foundation, either version 3 of the License, or

(at your option) any later version.

This program is distributed in the hope that it will be useful,

but WITHOUT ANY WARRANTY; without even the implied warranty of

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

GNU General Public License for more details.

You should have received a copy of the GNU General Public License

along with this program.  If not, see <http://www.gnu.org/licenses/>.

In addition, as a special exception, the copyright holders give

permission to link the code of portions of this program with the

OpenSSL library under certain conditions as described in each

individual source file, and distribute linked combinations

including the two.

You must obey the GNU General Public License in all respects

for all of the code used other than OpenSSL.  If you modify

file(s) with this exception, you may extend this exception to your

version of the file(s), but you are not obligated to do so.  If you

do not wish to do so, delete this exception statement from your

version.  If you delete this exception statement from all source

files in the program, then also delete it here.

MIT License

Copyright (c) 2018 Diego Giagio <diego@giagio.com>

Permission is hereby granted, free of charge, to any person obtaining a copy

of this software and associated documentation files (the "Software"), to deal

in the Software without restriction, including without limitation the rights

to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

copies of the Software, and to permit persons to whom the Software is

furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all

copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

SOFTWARE.

      url = 'https://plugins.gradle.org/m2/'

  maven { url = 'https://oss.sonatype.org/content/repositories/snapshots' }

  maven { url = 'https://nexus.bedatadriven.com/content/groups/public' }

    url = 'https://css4j.github.io/maven'

      includeGroupByRegex 'io\\.sf\\..*'

String[] os = [ 'win', 'mac', 'linux' ]

if( project.hasProperty( 'targetOs' ) ) {

  if( 'windows' == targetOs ) {

    os = [ 'win' ]

  } else if( 'macos' == targetOs ) {

    os = [ 'mac' ]

    os = [ targetOs ]

  modules = [ 'javafx.base', 'javafx.controls', 'javafx.graphics', 'javafx.swing' ]

  def v_junit = '5.13.4'

  def v_platform = '1.13.4'

  def v_jackson = '2.19.2'

  def v_echosvg = '2.2'

  def v_picocli = '4.7.7'

  implementation 'org.controlsfx:controlsfx:11.2.2'

  implementation 'org.fxmisc.richtext:richtextfx:0.11.5'

  implementation 'org.fxmisc.flowless:flowless:0.7.4'

  implementation 'org.openjfx:javafx-media:26-ea+3'

  implementation 'com.panemu:tiwulfx-dock:0.5'

  implementation 'org.yaml:snakeyaml:2.4'

  implementation 'org.jsoup:jsoup:1.18.3'

  implementation 'org.xhtmlrenderer:flying-saucer-core:9.11.2'

  implementation 'org.apache.commons:commons-compress:1.28.0'

  implementation "org.apache.commons:commons-vfs2:2.10.0"

  implementation 'org.codehaus.plexus:plexus-utils:4.0.2'

  // Logging.

  implementation 'org.slf4j:slf4j-api:2.1.0-alpha1'

  implementation 'org.slf4j:slf4j-nop:2.0.16'

  implementation fileTree( include: [ '**/*.jar' ], dir: 'libs' )

  def fx = [ 'controls', 'graphics', 'fxml', 'swing' ]

  testRuntimeOnly "org.junit.jupiter:junit-jupiter-engine:${v_junit}"

  testRuntimeOnly "org.junit.platform:junit-platform-engine:${v_platform}"

  testRuntimeOnly "org.junit.platform:junit-platform-launcher:${v_platform}"

  testImplementation 'org.junit.jupiter:junit-jupiter:${v_junit}'

  testImplementation 'org.assertj:assertj-core:3.27.4'

      from { [ 'LICENSE.md', 'README.md' ] }

host-path.txt

FROM alpine:latest

ENV CONTEXT_ARCH=linuxmusl-64

ADD "http://lmtx.pragma-ade.nl/install-lmtx/context-$CONTEXT_ARCH.zip" "context.zip"

  apk update && \

    add ca-certificates curl fontconfig rsync

RUN apk --update --no-cache add inkscape

RUN \

  echo "export PATH=\"\$PATH:\$CONTEXT_HOME/tex/texmf-$CONTEXT_ARCH/bin\"" >> $PROFILE && \

  source $PROFILE \

## Themes

If changes have been made to the themes, upgrade them as follows:

1. Change to the themes repository directory.

    cd $HOME/dev/java/keenwrite/themes

1. Tag the themes, such as:

    git tag -a 1.11.0 -m "message"

    git push --tags

1. Ensure the personal access token exists:

    test -f tokens/release.pat && echo "exists"

1. Create the release and release notes via the web.

1. Run the release script to upload the release akchive:

    ./release.sh

1. Edit `src/main/resources/com/keenwrite/messages.properties`.

1. Set `Wizard.typesetter.themes.version` to the version.

1. Set `Wizard.typesetter.themes.checksum` to the checksum.

The themes are released.

## Container

1. Set `Wizard.typesetter.container.version` to the new container version.

Building the container will pull from the container version in the properties

file. Ensure that a personal access token (`token.txt`) exists, then publish

the changes to the container image as follows:

./manage.sh --verbose --delete --build --export --publish

set -euo pipefail  # Exit on error, undefined vars, and pipe failures

source ../scripts/build-template

# Reads the value of a property from a properties file.

#

# $1 - The key name to obtain.

function property {

  if [[ ! -f "${PROPERTIES}" ]]; then

    echo "Error: Properties file ${PROPERTIES} not found" >&2

    exit 1

  fi

  grep "^${1}" "${PROPERTIES}" | cut -d'=' -f2

}

readonly BUILD_DIR=build

readonly PROPERTIES="${SCRIPT_DIR}/../src/main/resources/com/keenwrite/messages.properties"

readonly CONTAINER_EXE=podman

readonly CONTAINER_SHORTNAME=$(property Wizard.typesetter.container.image.name)

readonly CONTAINER_VERSION=$(property Wizard.typesetter.container.image.version)

readonly CONTAINER_NETWORK=host

readonly CONTAINER_IMAGE_FILE="${CONTAINER_SHORTNAME}-${CONTAINER_VERSION}"

readonly CONTAINER_IMAGE_PATH="${BUILD_DIR}/${CONTAINER_IMAGE_FILE}"

readonly CONTAINER_ARCHIVE_FILE="${CONTAINER_IMAGE_FILE}.tar"

readonly CONTAINER_ARCHIVE_PATH="${BUILD_DIR}/${CONTAINER_ARCHIVE_FILE}"

readonly CONTAINER_COMPRESSED_FILE="${CONTAINER_ARCHIVE_FILE}.gz"

readonly CONTAINER_COMPRESSED_PATH="${BUILD_DIR}/${CONTAINER_COMPRESSED_FILE}"

readonly CONTAINER_DIR_SOURCE="/root/source"

readonly CONTAINER_DIR_TARGET="/root/target"

readonly CONTAINER_DIR_IMAGES="/root/images"

readonly CONTAINER_DIR_FONTS="/root/fonts"

ARG_CONTAINER_NAME="${CONTAINER_SHORTNAME}:${CONTAINER_VERSION}"

ARG_CONTAINER_COMMAND="context --version"

ARG_MOUNTPOINT_SOURCE=""

ARG_MOUNTPOINT_TARGET="."

ARG_MOUNTPOINT_IMAGES=""

ARG_MOUNTPOINT_FONTS="${HOME}/.fonts"

DEPENDENCIES=(

  "podman,https://podman.io"

  "tar,https://www.gnu.org/software/tar"

  "bzip2,https://gitlab.com/bzip2/bzip2"

)

ARGUMENTS+=(

  "b,build,Build container"

  "c,connect,Connect to container"

  "d,delete,Remove all containers"

  "s,source,Set mount point for input document (before typesetting)"

  "t,target,Set mount point for output file (after typesetting)"

  "i,images,Set mount point for image files (to typeset)"

  "f,fonts,Set mount point for font files (during typesetting)"

  "l,load,Load container (${CONTAINER_COMPRESSED_PATH})"

  "p,publish,Publish the container"

  "r,run,Run a command in the container (\"${ARG_CONTAINER_COMMAND}\")"

  "x,export,Save container (${CONTAINER_COMPRESSED_PATH})"

)

# ---------------------------------------------------------------------------

# Manages the container.

# ---------------------------------------------------------------------------

execute() {

  ${do_delete}

  ${do_build}

  ${do_export}

  ${do_publish}

  ${do_load}

  ${do_execute}

  ${do_connect}

  return 1

}

# ---------------------------------------------------------------------------

# Deletes all containers.

# ---------------------------------------------------------------------------

utile_delete() {

  [[ -f ${CONTAINER_IMAGE_PATH} ]] && \

    $log "Deleting ${CONTAINER_IMAGE_PATH}"; \

    rm -f "${CONTAINER_IMAGE_PATH}"

  $log "Deleting all containers"

  ${CONTAINER_EXE} rmi --all --force > /dev/null || true

  $log "Containers deleted"

}

# ---------------------------------------------------------------------------

# Builds the container file in the current working directory.

# ---------------------------------------------------------------------------

utile_build() {

  $log "Building container version ${CONTAINER_VERSION}"

  mkdir -p "${ARG_MOUNTPOINT_FONTS}"

  # Show what commands are run while building, but not the commands' output.

  ${CONTAINER_EXE} build \

    --network="${CONTAINER_NETWORK}" \

    --squash \

    -t "${ARG_CONTAINER_NAME}" . | \

  grep ^STEP || true

}

# ---------------------------------------------------------------------------

# Publishes the container to the repository.

# ---------------------------------------------------------------------------

utile_publish() {

  local -r HOST_PATH="host-path.txt"

  if [[ -f "${HOST_PATH}" ]]; then

    local -r repository=$(cat "${HOST_PATH}")

    local -r remote_file="${CONTAINER_SHORTNAME}:${CONTAINER_VERSION}"

    local -r remote_path="${repository}/${remote_file}"

    $log "Publishing ${CONTAINER_IMAGE_PATH} to ${remote_path}"

    # Path to the repository.

    scp -q "${CONTAINER_IMAGE_PATH}" "${remote_path}"

  else

    error "Create ${HOST_PATH} with path on remote host"

  fi

}

# ---------------------------------------------------------------------------

# Creates the command-line option for a read-only mountpoint.

#

# $1 - The host directory.

# $2 - The guest (container) directory.

# $3 - The file system permissions (set to 1 for read-write).

# ---------------------------------------------------------------------------

get_mountpoint() {

  local result=""

  local binding="ro"

  if [[ -n "${3:-}" ]]; then

    binding="Z"

  fi

  if [[ -n "${1:-}" ]]; then

    result="-v ${1}:${2}:${binding}"

  fi

  echo "${result}"

}

get_mountpoint_source() {

  echo "$(get_mountpoint "${ARG_MOUNTPOINT_SOURCE}" "${CONTAINER_DIR_SOURCE}")"

}

get_mountpoint_target() {

  echo "$(get_mountpoint "${ARG_MOUNTPOINT_TARGET}" "${CONTAINER_DIR_TARGET}" 1)"

}

get_mountpoint_images() {

  echo "$(get_mountpoint "${ARG_MOUNTPOINT_IMAGES}" "${CONTAINER_DIR_IMAGES}")"

}

get_mountpoint_fonts() {

  echo "$(get_mountpoint "${ARG_MOUNTPOINT_FONTS}" "${CONTAINER_DIR_FONTS}")"

}

# ---------------------------------------------------------------------------

# Connects to the container.

# ---------------------------------------------------------------------------

utile_connect() {

  $log "Connecting to container"

  local mount_source

  local mount_target

  local mount_images

  local mount_fonts

  mount_source=$(get_mountpoint_source)

  mount_target=$(get_mountpoint_target)

  mount_images=$(get_mountpoint_images)

  mount_fonts=$(get_mountpoint_fonts)

  $log "mount_source = '${mount_source}'"

  $log "mount_target = '${mount_target}'"

  $log "mount_images = '${mount_images}'"

  $log "mount_fonts  = '${mount_fonts}'"

  # Use array to properly handle empty mount options

  local mount_args=()

  [[ -n "${mount_source}" ]] && mount_args+=(${mount_source})

  [[ -n "${mount_target}" ]] && mount_args+=(${mount_target})

  [[ -n "${mount_images}" ]] && mount_args+=(${mount_images})

  [[ -n "${mount_fonts}"  ]] && mount_args+=(${mount_fonts})

  # Ensure directories exist and log creation

  for mount in "${mount_args[@]}"; do

    # Extract host path from mount string (format: -v /host:/container)

    host_path=$(echo "${mount}" | sed 's/^-v \([^:]*\):.*$/\1/')

    [[ ! -d "$host_path" ]] && \

      $log "Create directory: $host_path" && \

      mkdir -p "$host_path"

  done

  ${CONTAINER_EXE} run \

    --network="${CONTAINER_NETWORK}" \

    --rm \

    -it \

    "${mount_args[@]}" \

    "${ARG_CONTAINER_NAME}"

}

# ---------------------------------------------------------------------------

# Runs a command in the container.

#

# Examples:

#

#   ./manage.sh -r "ls /"

#   ./manage.sh -r "context --version"

# ---------------------------------------------------------------------------

utile_execute() {

  $log "Running \"${ARG_CONTAINER_COMMAND}\":"

  ${CONTAINER_EXE} run \

    --network="${CONTAINER_NETWORK}" \

    --rm \

    -it \

    "${ARG_CONTAINER_NAME}" \

    /bin/sh --login -c "${ARG_CONTAINER_COMMAND}"

}

# ---------------------------------------------------------------------------

# Saves the container to a file.

# ---------------------------------------------------------------------------

utile_export() {

  if [[ -f "${CONTAINER_COMPRESSED_PATH}" ]]; then

    warning "${CONTAINER_COMPRESSED_PATH} exists, delete before saving."

  else

    $log "Saving ${CONTAINER_SHORTNAME} image"

    mkdir -p "${BUILD_DIR}"

    ${CONTAINER_EXE} save \

      --quiet \

      -o "${CONTAINER_ARCHIVE_PATH}" \

      "${ARG_CONTAINER_NAME}"

    $log "Compressing to ${CONTAINER_COMPRESSED_PATH}"

    gzip "${CONTAINER_ARCHIVE_PATH}"

    $log "Renaming to ${CONTAINER_IMAGE_PATH}"

    mv "${CONTAINER_COMPRESSED_PATH}" "${CONTAINER_IMAGE_PATH}"

    $log "Saved ${CONTAINER_IMAGE_PATH} image"

  fi

}

# ---------------------------------------------------------------------------

# Loads the container from a file.

# ---------------------------------------------------------------------------

utile_load() {

  if [[ -f "${CONTAINER_COMPRESSED_PATH}" ]]; then

    $log "Loading ${CONTAINER_SHORTNAME} from ${CONTAINER_COMPRESSED_PATH}"

    ${CONTAINER_EXE} load \

      --quiet \

      -i "${CONTAINER_COMPRESSED_PATH}"

    $log "Loaded ${CONTAINER_SHORTNAME} image"

  else

    warning "Missing ${CONTAINER_COMPRESSED_PATH}; use build followed by save"

  fi

}

argument() {

  local consume=1

  case "$1" in

    -b|--build)

    do_build=utile_build

    ;;

    -c|--connect)

    do_connect=utile_connect

    ;;

    -z|--delete)

    do_delete=utile_delete

    ;;

    -l|--load)

    do_load=utile_load

    ;;

    -i|--images)

    if [[ -n "${2:-}" ]]; then

      ARG_MOUNTPOINT_IMAGES="$2"

      consume=2

    fi

    ;;

    -t|--target)

    if [[ -n "${2:-}" ]]; then

      ARG_MOUNTPOINT_TARGET="$2"

      consume=2

    fi

    ;;

    -p|--publish)

    do_publish=utile_publish

    ;;

    -r|--run)

    do_execute=utile_execute

    if [[ -n "${2:-}" ]]; then

      ARG_CONTAINER_COMMAND="$2"

      consume=2

    fi

    ;;

    -s|--source)

    if [[ -n "${2:-}" ]]; then

      ARG_MOUNTPOINT_SOURCE="$2"

      consume=2

    fi

    ;;

    -x|--export)

    do_export=utile_export

    ;;

  esac

  return ${consume}

}

do_build=:

do_connect=:

do_delete=:

do_execute=:

do_load=:

do_publish=:

do_export=:

main "$@"

# Quotation marks

When converting straight single quotes into curled single quotes, the

application offers a variety of entities to use for encoding:

* **regular** -- Do not encode.

* **modifier** -- Encode as \ʼ, the modifier letter apostrophe.

* **apos** -- Encode as \', curled when typeset to PDF.

* **aposhex** -- Encode as \', the apostrophe's numeric value.

* **quote** -- Encode as \’, the right single quotation mark, which

is typically curled in HTML and XHTML documents by default.

* **quotehex** -- Encode \’, the right single quotation mark's numeric

value.

When typsetting into a PDF document, only the semantically correct value

of \' will be curled automatically.

# History

Quotation marks trace back to Ancient Greek, later adopted to the diplé (⸖)

circa 625 BCE, foreshadowing its later curve. By the seventeenth century,

quotation marks grew common. During the nineteenth century, Western Europe

turned the convexity of quotation mark pairs outward.

Early mechanical typewriters, circa 1825, lacked many punctuation marks. As

technology improved, additional keys were added while some keys played dual

roles (such as I for 1). Straight single and double quotes could be co-opted

for quotation marks and apostrophes, feet and inches marks, and primes and

double-primes. There wasn't a pressing need to type curled versions because

humans excel at understanding from context.

Eventually straight quotes were codified for computers. Unfortunately, the

apostrophe carried with it the baggage from typewriters. That is, burgeoning

encoding standards failed to let users capture the nuances of the English

language; computers forced users to treat the apostrophe as a straight quote.

Standards bodies suggested using the right single quotation mark for an

apostrophe instead, shirking off its semantic meaning. Consequently,

text containing English quotations, especially British English, is now

riddled with ambiguity.

Consider the sentence:

> Ambiguity lurks in "'cause the horses'".

Does `'cause` mean _because_ or _induce_? The answer determines whether

an open left single quote is used or an apostrophe, semantically speaking.

It's amazing how ancient decisions still affect modern systems.

#!/usr/bin/env bash

readonly FONTS_DIR="/usr/local/share/fonts"

readonly DOWNLOAD_DIR=$(mktemp -d)

cleanup() {

  if [ -d "${DOWNLOAD_DIR}" ]; then

    rm -rf "${DOWNLOAD_DIR}"

  fi

}

trap cleanup EXIT

if [ ! -d "${FONTS_DIR}" ]; then

  echo "ERROR: Create ${FONTS_DIR} and ensure write access."

  exit 1

fi

while IFS=',' read -r url extension; do

  [[ -n "$url" ]] || continue

  filename=$(basename "${url}")

  if [ ! -d "${FONTS_DIR}/${extension}" ]; then

    echo "ERROR: Create ${FONTS_DIR}/${extension} and ensure write access."

    exit 1

  fi

  echo "Downloading ${url} to ${DOWNLOAD_DIR}"

  wget --quiet -P "${DOWNLOAD_DIR}" "${url}"

  font_dir="${FONTS_DIR}/${extension}"

  echo "Extracting ${extension} to ${font_dir}"

  unzip -j -o -d "${font_dir}" "${DOWNLOAD_DIR}/${filename}" "*.${extension}"

done < urls.csv

https://fonts.keenwrite.com/download/andada-pro.zip,otf

https://fonts.keenwrite.com/download/archivo-narrow.zip,otf

https://fonts.keenwrite.com/download/carlito.zip,ttf

https://fonts.keenwrite.com/download/courier-prime.zip,ttf

https://fonts.keenwrite.com/download/inconsolata.zip,ttf

https://fonts.keenwrite.com/download/libre-baskerville.zip,ttf

https://fonts.keenwrite.com/download/niconne.zip,ttf

https://fonts.keenwrite.com/download/nunito.zip,ttf

https://fonts.keenwrite.com/download/open-sans-emoji.zip,ttf

https://fonts.keenwrite.com/download/pt-mono.zip,ttf

https://fonts.keenwrite.com/download/pt-sans.zip,ttf

https://fonts.keenwrite.com/download/pt-serif.zip,ttf

https://fonts.keenwrite.com/download/roboto.zip,ttf

https://fonts.keenwrite.com/download/roboto-mono.zip,ttf

https://fonts.keenwrite.com/download/source-serif-4.zip,otf

https://fonts.keenwrite.com/download/underwood.zip,ttf

"\${SCRIPT_SRC}/${ARG_JAVA_DIR}/bin/java" ${OPT_JAVA} -jar "\${SCRIPT_SRC}/${FILE_APP_JAR}" "\$@"

"%SCRIPT_DIR%\\${ARG_JAVA_DIR}\\bin\\java" ${OPT_JAVA} -jar "%SCRIPT_DIR%\\${FILE_APP_JAR}" %*

  ${SCRIPT_DIR}/bin/osslsigncode sign \

  packer=${SCRIPT_DIR}/bin/warp-packer

    packer=${SCRIPT_DIR}/bin/linux-x64.warp-packer

23.0.1+13

import com.keenwrite.events.StatusEvent;

  /**

   * For XHTML exports, encode TeX as SVG. Treat image links relatively.

   */

  XHTML_TEX_SVG( ".xhtml" ),

    final var mediaType = MediaTypeExtension.fromExtension( extension );

    return valueFrom( mediaType, modifier );

    final var svg = "svg".equalsIgnoreCase( modifier.trim() );

      case TEXT_HTML -> svg

      case TEXT_XML, APP_XHTML -> svg

        ? XHTML_TEX_SVG

        : XHTML_TEX;

/* Copyright 2020-2024 White Magic Software, Ltd. -- All rights reserved.

 *

 * SPDX-License-Identifier: MIT

 */

package com.keenwrite;

import com.keenwrite.cmdline.HeadlessApp;

import com.keenwrite.events.HyperlinkOpenEvent;

import com.keenwrite.events.StatusEvent;

import com.keenwrite.preferences.Workspace;

import com.keenwrite.preview.MathRenderer;

import com.keenwrite.spelling.impl.Lexicon;

import javafx.application.Application;

import javafx.event.Event;

import javafx.event.EventType;

import javafx.scene.input.KeyCode;

import javafx.scene.input.KeyEvent;

import javafx.stage.Stage;

import org.greenrobot.eventbus.Subscribe;

import java.util.function.BooleanSupplier;

import java.util.logging.FileHandler;

import java.util.logging.Level;

import java.util.logging.Logger;

import static com.keenwrite.Bootstrap.APP_TITLE;

import static com.keenwrite.constants.GraphicsConstants.LOGOS;

import static com.keenwrite.events.Bus.register;

import static com.keenwrite.preferences.AppKeys.*;

import static com.keenwrite.util.FontLoader.initFonts;

import static java.util.logging.Logger.getLogger;

import static javafx.scene.input.KeyCode.F11;

import static javafx.scene.input.KeyEvent.KEY_PRESSED;

import static javafx.scene.input.KeyEvent.KEY_RELEASED;

import static javafx.stage.WindowEvent.WINDOW_SHOWN;

/**

 * The application allows users to edit plain text files in a markup notation

 * and see a real-time preview of the formatted output.

 */

public final class GuiApp extends Application {

  private Workspace mWorkspace;

  private final static Logger sLogger =

    getLogger( GuiApp.class.getCanonicalName() );

  /**

   * GUI application entry point. See {@link HeadlessApp} for the entry

   * point to the command-line application.

   *

   * @param args Command-line arguments.

   */

  public static void run( final String[] args ) {

    setLogLevel( sLogger, Level.FINE );

    launch( args );

  }

  @SuppressWarnings( "SameParameterValue" )

  private static void setLogLevel( final Logger logger, final Level level ) {

    final var handlers = logger.getHandlers();

    logger.setLevel( level );

    for( final var h : handlers ) {

      if( h instanceof FileHandler ) {

        h.setLevel( level );

      }

    }

  }

  /**

   * Creates an instance of {@link KeyEvent} that represents pressing a key.

   *

   * @param code  The key to simulate being pressed down.

   * @param shift Whether shift key modifier shall modify the key code.

   * @return An instance of {@link KeyEvent} that may be used to simulate

   * a key being pressed.

   */

  public static Event keyDown( final KeyCode code, final boolean shift ) {

    return keyEvent( KEY_PRESSED, code, shift );

  }

  /**

   * Creates an instance of {@link KeyEvent} that represents a key released

   * event without any modifier keys held.

   *

   * @param code The key code representing a key to simulate releasing.

   * @return An instance of {@link KeyEvent}.

   */

  public static Event keyDown( final KeyCode code ) {

    return keyDown( code, false );

  }

  /**

   * Creates an instance of {@link KeyEvent} that represents releasing a key.

   *

   * @param code  The key to simulate being released up.

   * @param shift Whether shift key modifier shall modify the key code.

   * @return An instance of {@link KeyEvent} that may be used to simulate

   * a key being released.

   */

  @SuppressWarnings( "unused" )

  public static Event keyUp( final KeyCode code, final boolean shift ) {

    return keyEvent( KEY_RELEASED, code, shift );

  }

  private static Event keyEvent(

    final EventType<KeyEvent> type, final KeyCode code, final boolean shift ) {

    return new KeyEvent(

      type, "", "", code, shift, false, false, false

    );

  }

  /**

   * JavaFX entry point.

   *

   * @param stage The primary application stage.

   */

  @Override

  public void start( final Stage stage ) {

    // Must be instantiated after the UI is initialized (i.e., not in main)

    // because it interacts with GUI properties.

    mWorkspace = new Workspace();

    // The locale was already loaded when the workspace was created. This

    // ensures that when the locale preference changes, a new spellchecker

    // instance will be loaded and applied.

    final var property = mWorkspace.localeProperty( KEY_LANGUAGE_LOCALE );

    property.addListener( ( _, _, _ ) -> readLexicon() );

    initFonts();

    initState( stage );

    initStage( stage );

    initIcons( stage );

    initScene( stage );

    MathRenderer.bindSize( mWorkspace.doubleProperty( KEY_UI_FONT_MATH_SIZE ) );

    // Load the lexicon and check all the documents after all files are open.

    stage.addEventFilter( WINDOW_SHOWN, _ -> readLexicon() );

    stage.show();

    register( this );

  }

  private void initState( final Stage stage ) {

    final var enable = createBoundsEnabledSupplier( stage );

    stage.setX( mWorkspace.getDouble( KEY_UI_WINDOW_X ) );

    stage.setY( mWorkspace.getDouble( KEY_UI_WINDOW_Y ) );

    stage.setWidth( mWorkspace.getDouble( KEY_UI_WINDOW_W ) );

    stage.setHeight( mWorkspace.getDouble( KEY_UI_WINDOW_H ) );

    stage.setMaximized( mWorkspace.getBoolean( KEY_UI_WINDOW_MAX ) );

    stage.setFullScreen( mWorkspace.getBoolean( KEY_UI_WINDOW_FULL ) );

    mWorkspace.listen( KEY_UI_WINDOW_X, stage.xProperty(), enable );

    mWorkspace.listen( KEY_UI_WINDOW_Y, stage.yProperty(), enable );

    mWorkspace.listen( KEY_UI_WINDOW_W, stage.widthProperty(), enable );

    mWorkspace.listen( KEY_UI_WINDOW_H, stage.heightProperty(), enable );

    mWorkspace.listen( KEY_UI_WINDOW_MAX, stage.maximizedProperty() );

    mWorkspace.listen( KEY_UI_WINDOW_FULL, stage.fullScreenProperty() );

  }

  private void initStage( final Stage stage ) {

    stage.setTitle( APP_TITLE );

    stage.addEventHandler( KEY_PRESSED, event -> {

      if( F11.equals( event.getCode() ) ) {

        stage.setFullScreen( !stage.isFullScreen() );

      }

    } );

  }

  private void initIcons( final Stage stage ) {

    stage.getIcons().addAll( LOGOS );

  }

  private void initScene( final Stage stage ) {

    final var mainScene = new MainScene( mWorkspace );

    stage.setScene( mainScene.getScene() );

  }

  /**

   * When a hyperlink website URL is clicked, this method is called to launch

   * the default browser to the event's location.

   *

   * @param event The event called when a hyperlink was clicked.

   */

  @Subscribe

  public void handle( final HyperlinkOpenEvent event ) {

    getHostServices().showDocument( event.getUri().toString() );

  }

  /**

   * When a status message is shown, write it to the console.

   *

   * @param event The event published when the status changes.

   */

  @Subscribe

  public void handle( final StatusEvent event ) {

    assert event != null;

    assert sLogger != null;

    sLogger.info( event.getMessage() );

  }

  /**

   * This will load the lexicon for the user's preferred locale and fire

   * an event when the all entries in the lexicon have been loaded.

   */

  private void readLexicon() {

    Lexicon.read( mWorkspace.getLocale() );

  }

  /**

   * When the window is maximized, full screen, or iconified, prevent updating

   * the window bounds. This is used so that if the user exits the application

   * when full screen (or maximized), restarting the application will recall

   * the previous bounds, allowing for continuity of expected behaviour.

   *

   * @param stage The window to check for "normal" status.

   * @return {@code false} when the bounds must not be changed, ergo

   * persisted.

   */

  private BooleanSupplier createBoundsEnabledSupplier( final Stage stage ) {

    return () ->

      !(stage.isMaximized() || stage.isFullScreen() || stage.isIconified());

  }

}

/* Copyright 2020-2024 White Magic Software, Ltd. -- All rights reserved.

 *

 * SPDX-License-Identifier: MIT

 */

import java.io.PrintStream;

 * This is the main entry point to the application. The {@link Launcher} class

 * is responsible for running the application using either the {@link GuiApp} or

 * {@link HeadlessApp} class, depending on whether running with command-line

 * arguments.

  static {

    // We don't care about the logging provider connection message.

    System.setProperty( "slf4j.internal.verbosity", "WARN" );

  }

  /**

   * Where to write error messages.

   */

  private static final PrintStream ERRORS = System.err;

  private static void terminate( final int exitCode ) {

    final var parseResult = parser.parseArgs( args );