Dave Jarvis' Repositories

* Diagrams: Mermaid, GraphViz, UML, sequence, timing, and [many more](https://kroki.io/)!

Diagram that includes variables:

  def v_junit = '5.5.1'

  def v_jackson = '2.12.0'

  def v_batik = '1.13'

  implementation 'net.sf.saxon:Saxon-HE:10.1'

  implementation 'xalan:xalan:2.7.2'

* [texample.Rmd](texample.Rmd) -- Numerous examples of formulas

*Song of the Yellow Bird*:

	翩翩黃鳥，

	雌雄相依。

	念我之獨，

	誰其與歸?

English translation:

	Orioles fly smoothly

	Female and male cuddle close together

	Thinking of my loneliness

	Whom shall I go with?

Fonts:

* Regular: 활판 인쇄술

* Bold: **활판 인쇄술**

* Monospace: `활판 인쇄술`

* Monospace bold: **`활판 인쇄술`**

* Math: $E=mc^2$

---

formula:

  sqrt:

    value: "420"

  quadratic:

    a: "25"

    b: "84.906"

    c: "20"

![Logo](images/app-title)

Given the quadratic formula:

$x = \frac{-b \pm \sqrt{b^2 -4ac}}{2a}$

Formatted in an R Markdown document as follows:

    $x = \frac{-b \pm \sqrt{b^2 -4ac}}{2a}$

We can substitute the following values:

$a = `r# x(v$formula$quadratic$a)`, b = `r# x(v$formula$quadratic$b)`, c = `r# x(v$formula$quadratic$c)`$

`r# -x(v$formula$quadratic$b) + sqrt( v$formula$quadratic$b^2  - 4 * v$formula$quadratic$a * v$formula$quadratic$c )`

To arrive at two solutions:

$x = \frac{-b + \sqrt{b^2 -4ac}}{2a} = `r# (-x(v$formula$quadratic$b) + sqrt( x(v$formula$quadratic$b)^2  - 4 * x(v$formula$quadratic$a) * x(v$formula$quadratic$c) )) / (2 * x(v$formula$quadratic$a))`$

$x = \frac{-b - \sqrt{b^2 -4ac}}{2a} = `r# (-x(v$formula$quadratic$b) - sqrt( x(v$formula$quadratic$b)^2  - 4 * x(v$formula$quadratic$a) * x(v$formula$quadratic$c) )) / (2 * x(v$formula$quadratic$a))`$

Changing the variable values is reflected in the output immediately.

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

# Real-time equation rendering

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)`$

# Maxwell's equations

$rot \vec{E} = \frac{1}{c} \frac{\partial{\vec{B}}}{\partial t}, div \vec{B} = 0$

$rot \vec{B} = \frac{1}{c} \frac{\partial{\vec{E}}}{\partial t} + \frac{4\pi}{c} \vec{j}, div \vec{E} = 4 \pi \rho_{\varepsilon}$

# Time-dependent Schrödinger equation

$- \frac{{\hbar ^2 }}{{2m}}\frac{{\partial ^2 \psi (x,t)}}{{\partial x^2 }} + U(x)\psi (x,t) = i\hbar \frac{{\partial \psi (x,t)}}{{\partial t}}$

# Discrete-time Fourier transforms

Unit step function: $u(n) \Leftrightarrow \frac{1}{1-e^{-jw}} + \sum_{k=-\infty}^{\infty} \pi \delta (\omega + 2\pi k)$

Shifted delta: $\delta (n - n_o ) \Leftrightarrow e^{ - j\omega n_o }$

# Faraday's Law

$\oint_C {E \cdot d\ell  =  - \frac{d}{{dt}}} \int_S {B_n dA}$

# Infinite series

$sin(x) = \sum_{n = 1}^{\infty}  {\frac{{( { - 1})^{n - 1} x^{2n - 1} }}{{( {2n - 1})!}}}$

# Magnetic flux

$\phi _m  = \int_S {N{{B}} \cdot {{\hat n}}dA = } \int_S {NB_n dA}$

# Driven oscillation amplitude

$A = \frac{{F_0 }}{{\sqrt {m^2 ( {\omega _0^2  - \omega ^2 } )^2  + b^2 \omega ^2 } }}$

# Optics

$\phi  = \frac{{2\pi }}{\lambda }a sin(\theta)$

# Writes the name for all OTF files found in the current directory or lower

import com.keenwrite.outline.DocumentOutline;

import com.keenwrite.preferences.Key;

import com.keenwrite.preferences.Workspace;

import com.keenwrite.preview.HtmlPanel;

import com.keenwrite.preview.HtmlPreview;

import com.keenwrite.processors.Processor;

import com.keenwrite.processors.ProcessorContext;

import com.keenwrite.processors.ProcessorFactory;

import com.keenwrite.processors.markdown.extensions.CaretExtension;

import com.keenwrite.service.events.Notifier;

import com.keenwrite.sigils.RSigilOperator;

import com.keenwrite.sigils.SigilOperator;

import com.keenwrite.sigils.Tokens;

import com.keenwrite.sigils.YamlSigilOperator;

import com.panemu.tiwulfx.control.dock.DetachableTab;

import com.panemu.tiwulfx.control.dock.DetachableTabPane;

import javafx.application.Platform;

import javafx.beans.property.*;

import javafx.collections.ListChangeListener;

import javafx.event.ActionEvent;

import javafx.event.Event;

import javafx.event.EventHandler;

import javafx.scene.Node;

import javafx.scene.Scene;

import javafx.scene.control.SplitPane;

import javafx.scene.control.Tab;

import javafx.scene.control.TabPane;

import javafx.scene.control.Tooltip;

import javafx.scene.control.TreeItem.TreeModificationEvent;

import javafx.scene.input.KeyEvent;

import javafx.stage.Stage;

import javafx.stage.Window;

import org.greenrobot.eventbus.Subscribe;

import java.io.File;

import java.io.FileNotFoundException;

import java.nio.file.Path;

import java.util.*;

import java.util.concurrent.atomic.AtomicBoolean;

import java.util.function.Function;

import java.util.stream.Collectors;

import static com.keenwrite.Constants.*;

import static com.keenwrite.ExportFormat.NONE;

import static com.keenwrite.Messages.get;

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

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

import static com.keenwrite.io.MediaType.*;

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

import static com.keenwrite.processors.IdentityProcessor.IDENTITY;

import static com.keenwrite.processors.ProcessorFactory.createProcessors;

import static java.util.stream.Collectors.groupingBy;

import static javafx.application.Platform.runLater;

import static javafx.scene.control.ButtonType.NO;

import static javafx.scene.control.ButtonType.YES;

import static javafx.scene.control.TabPane.TabClosingPolicy.ALL_TABS;

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

import static javafx.scene.input.KeyCombination.CONTROL_DOWN;

import static javafx.util.Duration.millis;

import static javax.swing.SwingUtilities.invokeLater;

import static org.fxmisc.wellbehaved.event.EventPattern.keyPressed;

/**

 * Responsible for wiring together the main application components for a

 * particular workspace (project). These include the definition views,

 * text editors, and preview pane along with any corresponding controllers.

 */

public final class MainPane extends SplitPane {

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

  /**

   * Used when opening files to determine how each file should be binned and

   * therefore what tab pane to be opened within.

   */

  private static final Set<MediaType> PLAIN_TEXT_FORMAT = Set.of(

    TEXT_MARKDOWN, TEXT_R_MARKDOWN, TEXT_R_XML, UNDEFINED

  );

  /**

   * Prevents re-instantiation of processing classes.

   */

  private final Map<TextResource, Processor<String>> mProcessors =

    new HashMap<>();

  private final Workspace mWorkspace;

  /**

   * Groups similar file type tabs together.

   */

  private final Map<MediaType, TabPane> mTabPanes = new HashMap<>();

  /**

   * Stores definition names and values.

   */

  private final Map<String, String> mResolvedMap =

    new HashMap<>( MAP_SIZE_DEFAULT );

  /**

   * Renders the actively selected plain text editor tab.

   */

  private final HtmlPreview mPreview;

  /**

   * Provides an interactive document outline.

   */

  private final DocumentOutline mOutline = new DocumentOutline();

  /**

   * Changing the active editor fires the value changed event. This allows

   * refreshes to happen when external definitions are modified and need to

   * trigger the processing chain.

   */

  private final ObjectProperty<TextEditor> mActiveTextEditor =

    createActiveTextEditor();

  /**

   * Changing the active definition editor fires the value changed event. This

   * allows refreshes to happen when external definitions are modified and need

   * to trigger the processing chain.

   */

  private final ObjectProperty<TextDefinition> mActiveDefinitionEditor =

    createActiveDefinitionEditor( mActiveTextEditor );

  /**

   * Tracks the number of detached tab panels opened into their own windows,

   * which allows unique identification of subordinate windows by their title.

   * It is doubtful more than 128 windows, much less 256, will be created.

   */

  private byte mWindowCount;

  /**

   * Called when the definition data is changed.

   */

  private final EventHandler<TreeModificationEvent<Event>> mTreeHandler =

    event -> {

      final var editor = mActiveDefinitionEditor.get();

      resolve( editor );

      process( getActiveTextEditor() );

      save( editor );

    };

  /**

   * Adds all content panels to the main user interface. This will load the

   * configuration settings from the workspace to reproduce the settings from

   * a previous session.

   */

  public MainPane( final Workspace workspace ) {

    mWorkspace = workspace;

    mPreview = new HtmlPreview( workspace );

    open( bin( getRecentFiles() ) );

    viewPreview();

    setDividerPositions( calculateDividerPositions() );

    // Once the main scene's window regains focus, update the active definition

    // editor to the currently selected tab.

    runLater(

      () -> getWindow().setOnCloseRequest( ( event ) -> {

        // Order matters here. We want to close all the tabs to ensure each

        // is saved, but after they are closed, the workspace should still

        // retain the list of files that were open. If this line came after

        // closing, then restarting the application would list no files.

        mWorkspace.save();

        if( closeAll() ) {

          Platform.exit();

          System.exit( 0 );

        }

        else {

          event.consume();

        }

      } )

    );

    register( this );

  }

  @Subscribe

  public void handle( final TextEditorFocusEvent event ) {

    mActiveTextEditor.set( event.get() );

  }

  @Subscribe

  public void handle( final TextDefinitionFocusEvent event ) {

    mActiveDefinitionEditor.set( event.get() );

  }

  /**

   * Typically called when a file name is clicked in the {@link HtmlPanel}.

   *

   * @param event The event to process, must contain a valid file reference.

   */

  @Subscribe

  public void handle( final FileOpenEvent event ) {

    final File eventFile;

    final var eventUri = event.getUri();

    if( eventUri.isAbsolute() ) {

      eventFile = new File( eventUri.getPath() );

    }

    else {

      final var activeFile = getActiveTextEditor().getFile();

      final var parent = activeFile.getParentFile();

      if( parent == null ) {

        clue( new FileNotFoundException( eventUri.getPath() ) );

        return;

      }

      else {

        final var parentPath = parent.getAbsolutePath();

        eventFile = Path.of( parentPath, eventUri.getPath() ).toFile();

      }

    }

    runLater( () -> open( eventFile ) );

  }

  @Subscribe

  public void handle( final CaretNavigationEvent event ) {

    runLater( () -> {

      final var textArea = getActiveTextEditor().getTextArea();

      textArea.moveTo( event.getOffset() );

      textArea.requestFollowCaret();

      textArea.requestFocus();

    } );

  }

  /**

   * TODO: Load divider positions from exported settings, see bin() comment.

   */

  private double[] calculateDividerPositions() {

    final var ratio = 100f / getItems().size() / 100;

    final var positions = getDividerPositions();

    for( int i = 0; i < positions.length; i++ ) {

      positions[ i ] = ratio * i;

    }

    return positions;

  }

  /**

   * Opens all the files into the application, provided the paths are unique.

   * This may only be called for any type of files that a user can edit

   * (i.e., update and persist), such as definitions and text files.

   *

   * @param files The list of files to open.

   */

  public void open( final List<File> files ) {

    files.forEach( this::open );

  }

  /**

   * This opens the given file. Since the preview pane is not a file that

   * can be opened, it is safe to add a listener to the detachable pane.

   *

   * @param file The file to open.

   */

  private void open( final File file ) {

    final var tab = createTab( file );

    final var node = tab.getContent();

    final var mediaType = MediaType.valueFrom( file );

    final var tabPane = obtainTabPane( mediaType );

    tab.setTooltip( createTooltip( file ) );

    tabPane.setFocusTraversable( false );

    tabPane.setTabClosingPolicy( ALL_TABS );

    tabPane.getTabs().add( tab );

    // Attach the tab scene factory for new tab panes.

    if( !getItems().contains( tabPane ) ) {

      addTabPane(

        node instanceof TextDefinition ? 0 : getItems().size(), tabPane

      );

    }

    getRecentFiles().add( file.getAbsolutePath() );

  }

  /**

   * Opens a new text editor document using the default document file name.

   */

  public void newTextEditor() {

    open( DOCUMENT_DEFAULT );

  }

  /**

   * Opens a new definition editor document using the default definition

   * file name.

   */

  public void newDefinitionEditor() {

    open( DEFINITION_DEFAULT );

  }

  /**

   * Iterates over all tab panes to find all {@link TextEditor}s and request

   * that they save themselves.

   */

  public void saveAll() {

    mTabPanes.forEach(

      ( mt, tp ) -> tp.getTabs().forEach( ( tab ) -> {

        final var node = tab.getContent();

        if( node instanceof TextEditor ) {

          save( ((TextEditor) node) );

        }

      } )

    );

  }

  /**

   * Requests that the active {@link TextEditor} saves itself. Don't bother

   * checking if modified first because if the user swaps external media from

   * an external source (e.g., USB thumb drive), save should not second-guess

   * the user: save always re-saves. Also, it's less code.

   */

  public void save() {

    save( getActiveTextEditor() );

  }

  /**

   * Saves the active {@link TextEditor} under a new name.

   *

   * @param file The new active editor {@link File} reference.

   */

  public void saveAs( final File file ) {

    assert file != null;

    final var editor = getActiveTextEditor();

    final var tab = getTab( editor );

    editor.rename( file );

    tab.ifPresent( t -> {

      t.setText( editor.getFilename() );

      t.setTooltip( createTooltip( file ) );

    } );

    save();

  }

  /**

   * Saves the given {@link TextResource} to a file. This is typically used

   * to save either an instance of {@link TextEditor} or {@link TextDefinition}.

   *

   * @param resource The resource to export.

   */

  private void save( final TextResource resource ) {

    try {

      resource.save();

    } catch( final Exception ex ) {

      clue( ex );

      sNotifier.alert(

        getWindow(), resource.getPath(), "TextResource.saveFailed", ex

      );

    }

  }

  /**

   * Closes all open {@link TextEditor}s; all {@link TextDefinition}s stay open.

   *

   * @return {@code true} when all editors, modified or otherwise, were

   * permitted to close; {@code false} when one or more editors were modified

   * and the user requested no closing.

   */

  public boolean closeAll() {

    var closable = true;

    for( final var entry : mTabPanes.entrySet() ) {

      final var tabPane = entry.getValue();

      final var tabIterator = tabPane.getTabs().iterator();

      while( tabIterator.hasNext() ) {

        final var tab = tabIterator.next();

        final var resource = tab.getContent();

        // The definition panes auto-save, so being specific here prevents

        // closing the definitions in the situation where the user wants to

        // continue editing (i.e., possibly save unsaved work).

        if( !(resource instanceof TextEditor) ) {

          continue;

        }

        if( canClose( (TextEditor) resource ) ) {

          tabIterator.remove();

          close( tab );

        }

        else {

          closable = false;

        }

      }

    }

    return closable;

  }

  /**

   * Calls the tab's {@link Tab#getOnClosed()} handler to carry out a close

   * event.

   *

   * @param tab The {@link Tab} that was closed.

   */

  private void close( final Tab tab ) {

    final var handler = tab.getOnClosed();

    if( handler != null ) {

      handler.handle( new ActionEvent() );

    }

  }

  /**

   * Closes the active tab; delegates to {@link #canClose(TextResource)}.

   */

  public void close() {

    final var editor = getActiveTextEditor();

    if( canClose( editor ) ) {

      close( editor );

    }

  }

  /**

   * Closes the given {@link TextResource}. This must not be called from within

   * a loop that iterates over the tab panes using {@code forEach}, lest a

   * concurrent modification exception be thrown.

   *

   * @param resource The {@link TextResource} to close, without confirming with

   *                 the user.

   */

  private void close( final TextResource resource ) {

    getTab( resource ).ifPresent(

      ( tab ) -> {

        tab.getTabPane().getTabs().remove( tab );

        close( tab );

      }

    );

  }

  /**

   * Answers whether the given {@link TextResource} may be closed.

   *

   * @param editor The {@link TextResource} to try closing.

   * @return {@code true} when the editor may be closed; {@code false} when

   * the user has requested to keep the editor open.

   */

  private boolean canClose( final TextResource editor ) {

    final var editorTab = getTab( editor );

    final var canClose = new AtomicBoolean( true );

    if( editor.isModified() ) {

      final var filename = new StringBuilder();

      editorTab.ifPresent( ( tab ) -> filename.append( tab.getText() ) );

      final var message = sNotifier.createNotification(

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

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

        filename.toString()

      );

      final var dialog = sNotifier.createConfirmation( getWindow(), message );

      dialog.showAndWait().ifPresent(

        save -> canClose.set( save == YES ? editor.save() : save == NO )

      );

    }

    return canClose.get();

  }

  private ObjectProperty<TextEditor> createActiveTextEditor() {

    final var editor = new SimpleObjectProperty<TextEditor>();

    editor.addListener( ( c, o, n ) -> {

      if( n != null ) {

        mPreview.setBaseUri( n.getPath() );

        process( n );

      }

    } );

    return editor;

  }

  /**

   * Adds the HTML preview tab to its own, singular tab pane.

   */

  public void viewPreview() {

    viewTab( mPreview, TEXT_HTML, get( "Pane.preview.title" ) );

  }

  /**

   * Adds the document outline tab to its own, singular tab pane.

   */

  public void viewOutline() {

    viewTab( mOutline, APP_DOCUMENT_OUTLINE, get( "Pane.outline.title" ) );

  }

  private void viewTab(

    final Node node, final MediaType mediaType, final String name ) {

    final var tabPane = obtainTabPane( mediaType );

    for( final var tab : tabPane.getTabs() ) {

      if( tab.getContent() == node ) {

        return;

      }

    }

    tabPane.getTabs().add( createTab( name, node ) );

import static com.keenwrite.preferences.WorkspaceKeys.KEY_UI_THEME_CUSTOM;

import static com.keenwrite.preferences.WorkspaceKeys.KEY_UI_THEME_SELECTION;

import static com.keenwrite.Constants.DEFINITION_DEFAULT;

import static com.keenwrite.Messages.get;

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

import static com.keenwrite.events.TextDefinitionFocusEvent.fireTextDefinitionFocus;

import static java.lang.String.format;

import static java.util.regex.Pattern.compile;

import static java.util.regex.Pattern.quote;

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 {

  private static final int GROUP_DELIMITED = 1;

  /**

   * Contains the root that is added to the view.

   */

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

  /**

   * Converts a tree item value to and from a string..

   */

  private final TreeItemConverter mConverter = new TreeItemConverter();

  /**

   * Contains a view of the definitions.

   */

  private final TreeView<String> mTreeView =

    new AltTreeView<>( mTreeRoot, mConverter );

  /**

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

  /**

   * File being edited by this editor instance.

   */

  private File mFile;

  /**

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

  /**

   * 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.setCellFactory( new TreeCellFactory() );

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

    setTop( buttonBar );

    setCenter( mTreeView );

    setAlignment( buttonBar, TOP_CENTER );

    mEncoding = open( mFile );

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

  }

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

  }