Dave Jarvis' Repositories

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

Download and install a full version of [OpenJDK 18](https://bell-sw.com/pages/downloads/#/java-18) that includes JavaFX module support, then run:

  @Subscribe

  public void handle( final InsertDefinitionEvent<String> event ) {

    final var leaf = event.getLeaf();

    final var editor = mTextEditor.get();

    System.out.println( "INJECT: " + leaf.toPath() );

    mVariableNameInjector.insert( editor, leaf );

  }

            insert( editor, leaf );

  }

  public void insert(

    final TextEditor editor,

    final DefinitionTreeItem<String> leaf ) {

    assert editor != null;

    assert leaf != null;

    final var mediaType = editor.getMediaType();

    final var operator = createOperator( mediaType );

    final var indexes = editor.getCaretWord();

    editor.replaceText( indexes, operator.apply( leaf.toPath() ) );

import com.keenwrite.events.InsertDefinitionEvent;

import com.keenwrite.events.TextDefinitionFocusEvent;

import com.keenwrite.processors.r.Engine;

import com.keenwrite.ui.tree.AltTreeView;

import com.keenwrite.ui.tree.TreeItemConverter;

import javafx.beans.property.BooleanProperty;

import javafx.beans.property.ReadOnlyBooleanProperty;

import javafx.beans.property.SimpleBooleanProperty;

import javafx.beans.value.ObservableValue;

import javafx.collections.ObservableList;

import javafx.event.ActionEvent;

import javafx.event.Event;

import javafx.event.EventHandler;

import javafx.scene.Node;

import javafx.scene.control.*;

import javafx.scene.input.KeyEvent;

import javafx.scene.layout.BorderPane;

import javafx.scene.layout.HBox;

import java.io.File;

import java.nio.charset.Charset;

import java.util.*;

import static com.keenwrite.Messages.get;

import static com.keenwrite.constants.Constants.*;

import static com.keenwrite.events.StatusEvent.clue;

import static com.keenwrite.ui.fonts.IconFactory.createGraphic;

import static javafx.geometry.Pos.CENTER;

import static javafx.geometry.Pos.TOP_CENTER;

import static javafx.scene.control.SelectionMode.MULTIPLE;

import static javafx.scene.control.TreeItem.childrenModificationEvent;

import static javafx.scene.control.TreeItem.valueChangedEvent;

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

/**

 * Provides the user interface that holds a {@link TreeView}, which

 * allows users to interact with key/value pairs loaded from the

 * document parser and adapted using a {@link TreeTransformer}.

 */

public final class DefinitionEditor extends BorderPane

  implements TextDefinition {

  /**

   * Contains the root that is added to the view.

   */

  private final DefinitionTreeItem<String> mTreeRoot = createRootTreeItem();

  /**

   * Contains a view of the definitions.

   */

  private final TreeView<String> mTreeView =

    new AltTreeView<>( mTreeRoot, new TreeItemConverter() );

  /**

   * Used to adapt the structured document into a {@link TreeView}.

   */

  private final TreeTransformer mTreeTransformer;

  /**

   * Handlers for key press events.

   */

  private final Set<EventHandler<? super KeyEvent>> mKeyEventHandlers

    = new HashSet<>();

  private final Map<String, String> mDefinitions = new HashMap<>();

  /**

   * Opened file's character encoding, or {@link Constants#DEFAULT_CHARSET} if

   * either no encoding could be determined or this is a new (empty) file.

   */

  private final Charset mEncoding;

  /**

   * Tracks whether the in-memory definitions have changed with respect to the

   * persisted definitions.

   */

  private final BooleanProperty mModified = new SimpleBooleanProperty();

  /**

   * File being edited by this editor instance, which may be renamed.

   */

  private File mFile;

  /**

   * This is provided for unit tests that are not backed by files.

   *

   * @param treeTransformer Responsible for transforming the definitions into

   *                        {@link TreeItem} instances.

   */

  public DefinitionEditor(

    final TreeTransformer treeTransformer ) {

    this( DEFINITION_DEFAULT, treeTransformer );

  }

  /**

   * Constructs a definition pane with a given tree view root.

   *

   * @param file The file of definitions to maintain through the UI.

   */

  public DefinitionEditor(

    final File file,

    final TreeTransformer treeTransformer ) {

    assert file != null;

    assert treeTransformer != null;

    mFile = file;

    mTreeTransformer = treeTransformer;

    mTreeView.setContextMenu( createContextMenu() );

    mTreeView.addEventFilter( KEY_PRESSED, this::keyEventFilter );

    mTreeView.focusedProperty().addListener( this::focused );

    getSelectionModel().setSelectionMode( MULTIPLE );

    final var buttonBar = new HBox();

    buttonBar.getChildren().addAll(

      createButton( "create", e -> createDefinition() ),

      createButton( "rename", e -> renameDefinition() ),

      createButton( "delete", e -> deleteDefinitions() )

    );

    buttonBar.setAlignment( CENTER );

    buttonBar.setSpacing( UI_CONTROL_SPACING );

    setTop( buttonBar );

    setCenter( mTreeView );

    setAlignment( buttonBar, TOP_CENTER );

    mEncoding = open( mFile );

    updateDefinitions( getDefinitions(), getTreeView().getRoot() );

    // After the file is opened, watch for changes, not before. Otherwise,

    // upon saving, users will be prompted to save a file that hasn't had

    // any modifications (from their perspective).

    addTreeChangeHandler( event -> {

      mModified.set( true );

      updateDefinitions( getDefinitions(), getTreeView().getRoot() );

    } );

  }

  /**

   * Replaces the given list of variable definitions with a flat hierarchy

   * of the converted {@link TreeView} root.

   *

   * @param definitions The definition map to update.

   * @param root        The values to flatten then insert into the map.

   */

  private void updateDefinitions(

    final Map<String, String> definitions,

    final TreeItem<String> root ) {

    definitions.clear();

    definitions.putAll( TreeItemMapper.convert( root ) );

    Engine.clear();

  }

  /**

   * Returns the variable definitions.

   *

   * @return The definition map.

   */

  @Override

  public Map<String, String> getDefinitions() {

    return mDefinitions;

  }

  @Override

  public void setText( final String document ) {

    final var foster = mTreeTransformer.transform( document );

    final var biological = getTreeRoot();

    for( final var child : foster.getChildren() ) {

      biological.getChildren().add( child );

    }

    getTreeView().refresh();

  }

  @Override

  public String getText() {

    final var result = new StringBuilder( 32768 );

    try {

      final var root = getTreeView().getRoot();

      final var problem = isTreeWellFormed();

      problem.ifPresentOrElse(

        node -> clue( "yaml.error.tree.form", node ),

        () -> result.append( mTreeTransformer.transform( root ) )

      );

    } catch( final Exception ex ) {

      // Catch errors while checking for a well-formed tree (e.g., stack smash).

      // Also catch any transformation exceptions (e.g., Json processing).

      clue( ex );

    }

    return result.toString();

  }

  @Override

  public File getFile() {

    return mFile;

  }

  @Override

  public void rename( final File file ) {

    mFile = file;

  }

  @Override

  public Charset getEncoding() {

    return mEncoding;

  }

  @Override

  public Node getNode() {

    return this;

  }

  @Override

  public ReadOnlyBooleanProperty modifiedProperty() {

    return mModified;

  }

  @Override

  public void clearModifiedProperty() {

    mModified.setValue( false );

  }

  private Button createButton(

    final String msgKey, final EventHandler<ActionEvent> eventHandler ) {

    final var keyPrefix = Constants.ACTION_PREFIX + "definition." + msgKey;

    final var button = new Button( get( keyPrefix + ".text" ) );

    final var graphic = createGraphic( get( keyPrefix + ".icon" ) );

    button.setOnAction( eventHandler );

    button.setGraphic( graphic );

    button.setTooltip( new Tooltip( get( keyPrefix + ".tooltip" ) ) );

    return button;

  }

  /**

   * Informs the caller of whenever any {@link TreeItem} in the {@link TreeView}

   * is modified. The modifications include: item value changes, item additions,

   * and item removals.

   * <p>

   * Safe to call multiple times; if a handler is already registered, the

   * old handler is used.

   * </p>

   *

   * @param handler The handler to call whenever any {@link TreeItem} changes.

   */

  public void addTreeChangeHandler(

    final EventHandler<TreeItem.TreeModificationEvent<Event>> handler ) {

    final var root = getTreeView().getRoot();

    root.addEventHandler( valueChangedEvent(), handler );

    root.addEventHandler( childrenModificationEvent(), handler );

  }

  /**

   * Answers whether the {@link TreeItem}s in the {@link TreeView} are suitably

   * well-formed for export. A tree is considered well-formed if the following

   * conditions are met:

   *

   * <ul>

   *   <li>The root node contains at least one child node having a leaf.</li>

   *   <li>There are no leaf nodes with sibling leaf nodes.</li>

   * </ul>

   *

   * @return {@code null} if the document is well-formed, otherwise the

   * problematic child {@link TreeItem}.

   */

  public Optional<TreeItem<String>> isTreeWellFormed() {

    final var root = getTreeView().getRoot();

    for( final var child : root.getChildren() ) {

      final var problemChild = isWellFormed( child );

      if( child.isLeaf() || problemChild != null ) {

        return Optional.ofNullable( problemChild );

      }

    }

    return Optional.empty();

  }

  /**

   * Determines whether the document is well-formed by ensuring that

   * child branches do not contain multiple leaves.

   *

   * @param item The subtree to check for well-formedness.

   * @return {@code null} when the tree is well-formed, otherwise the

   * problematic {@link TreeItem}.

   */

  private TreeItem<String> isWellFormed( final TreeItem<String> item ) {

    int childLeafs = 0;

    int childBranches = 0;

    for( final var child : item.getChildren() ) {

      if( child.isLeaf() ) {

        childLeafs++;

      }

      else {

        childBranches++;

      }

      final var problemChild = isWellFormed( child );

      if( problemChild != null ) {

        return problemChild;

      }

    }

    return ((childBranches > 0 && childLeafs == 0) ||

      (childBranches == 0 && childLeafs <= 1)) ? null : item;

  }

  @Override

  public DefinitionTreeItem<String> findLeafExact( final String text ) {

    return getTreeRoot().findLeafExact( text );

  }

  @Override

  public DefinitionTreeItem<String> findLeafContains( final String text ) {

    return getTreeRoot().findLeafContains( text );

  }

  @Override

  public DefinitionTreeItem<String> findLeafContainsNoCase(

    final String text ) {

    return getTreeRoot().findLeafContainsNoCase( text );

  }

  @Override

  public DefinitionTreeItem<String> findLeafStartsWith( final String text ) {

    return getTreeRoot().findLeafStartsWith( text );

  }

  public void select( final TreeItem<String> item ) {

    getSelectionModel().clearSelection();

    getSelectionModel().select( getTreeView().getRow( item ) );

  }

  /**

   * Collapses the tree, recursively.

   */

  public void collapse() {

    collapse( getTreeRoot().getChildren() );

  }

  /**

   * Collapses the tree, recursively.

   *

   * @param <T>   The type of tree item to expand (usually String).

   * @param nodes The nodes to collapse.

   */

  private <T> void collapse( final ObservableList<TreeItem<T>> nodes ) {

    for( final var node : nodes ) {

      node.setExpanded( false );

      collapse( node.getChildren() );

    }

  }

  /**

   * @return {@code true} when the user is editing a {@link TreeItem}.

   */

  private boolean isEditingTreeItem() {

    return getTreeView().editingItemProperty().getValue() != null;

  }

  /**

   * Changes to edit mode for the selected item.

   */

  @Override

  public void renameDefinition() {

    getTreeView().edit( getSelectedItem() );

  }

  /**

   * Removes all selected items from the {@link TreeView}.

   */

  @Override

  public void deleteDefinitions() {

    for( final var item : getSelectedItems() ) {

      final var parent = item.getParent();

      if( parent != null ) {

        parent.getChildren().remove( item );

      }

    }

  }

  /**

   * Deletes the selected item.

   */

  private void deleteSelectedItem() {

    final var c = getSelectedItem();

    getSiblings( c ).remove( c );

  }

  private void insertSelectedItem() {

    if( getSelectedItem() instanceof DefinitionTreeItem<String> node ) {

      if( node.isLeaf() ) {

        InsertDefinitionEvent.fire( node );

      }

    }

  }

  /**

   * Adds a new item under the selected item (or root if nothing is selected).

   * There are a few conditions to consider: when adding to the root,

   * when adding to a leaf, and when adding to a non-leaf. Items added to the

   * root must contain two items: a key and a value.

   */

  @Override

  public void createDefinition() {

    final var value = createDefinitionTreeItem();

    getSelectedItem().getChildren().add( value );

    expand( value );

    select( value );

  }

  private ContextMenu createContextMenu() {

    final var menu = new ContextMenu();

    final var items = menu.getItems();

    addMenuItem( items, ACTION_PREFIX + "definition.create.text" )

      .setOnAction( e -> createDefinition() );

    addMenuItem( items, ACTION_PREFIX + "definition.rename.text" )

      .setOnAction( e -> renameDefinition() );

    addMenuItem( items, ACTION_PREFIX + "definition.delete.text" )

      .setOnAction( e -> deleteSelectedItem() );

    addMenuItem( items, ACTION_PREFIX + "definition.insert.text" )

      .setOnAction( e -> insertSelectedItem() );

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

package com.keenwrite.events;

import com.keenwrite.editors.definition.DefinitionTreeItem;

/**

 * Collates information about a request to insert a reference to a

 * definition value into the active document.

 */

public class InsertDefinitionEvent<T> implements AppEvent {

  private final DefinitionTreeItem<T> mLeaf;

  private InsertDefinitionEvent( final DefinitionTreeItem<T> leaf ) {

    mLeaf = leaf;

  }

  public static <T> void fire( final DefinitionTreeItem<T> leaf ) {

    assert leaf != null;

    assert leaf.isLeaf();

    new InsertDefinitionEvent<>( leaf ).publish();

  }

  /**

   * Returns the {@link DefinitionTreeItem} that is to be inserted into the

   * active document.

   *

   * @return The item to insert (as a variable).

   */

  public DefinitionTreeItem<T> getLeaf() {

    return mLeaf;

  }

}

import com.whitemagicsoftware.keenquotes.parser.Contractions;

import com.whitemagicsoftware.keenquotes.parser.Curler;

import static com.whitemagicsoftware.keenquotes.lex.FilterType.FILTER_XML;

import static com.whitemagicsoftware.keenquotes.parser.Curler.CHARS;

  private final static Curler sTypographer =

    new Curler( contractions(), CHARS, FILTER_XML );

    return new Contractions.Builder().build();