Dave Jarvis' Repositories

org.gradle.daemon=true

org.gradle.parallel=true

@SuppressWarnings( {"FieldCanBeLocal", "unused", "RedundantSuppression"} )

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.Scene;

import javafx.scene.control.SplitPane;

import javafx.scene.control.Tab;

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 java.io.File;

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.StatusNotifier.clue;

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

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

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

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

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

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

import static javafx.application.Platform.runLater;

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 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, DetachableTabPane> 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 mHtmlPreview;

  /**

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

  /**

   * Responsible for creating a new scene when a tab is detached into

   * its own window frame.

   */

  private final DefinitionTabSceneFactory mDefinitionTabSceneFactory =

    createDefinitionTabSceneFactory( mActiveDefinitionEditor );

  /**

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

    mHtmlPreview = 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().focusedProperty().addListener( ( c, o, n ) -> {

          if( n != null && n ) {

            final var pane = mTabPanes.get( TEXT_YAML );

            final var model = pane.getSelectionModel();

            final var tab = model.getSelectedItem();

            if( tab != null ) {

              final var resource = tab.getContent();

              if( resource instanceof TextDefinition ) {

                mActiveDefinitionEditor.set( (TextDefinition) tab.getContent() );

              }

            }

          }

        } );

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

          }

        } );

      }

    );

  }

  /**

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

    final var newTabPane = !getItems().contains( tabPane );

    tab.setTooltip( createTooltip( file ) );

    tabPane.setFocusTraversable( false );

    tabPane.setTabClosingPolicy( ALL_TABS );

    tabPane.getTabs().add( tab );

    if( newTabPane ) {

      var index = getItems().size();

      if( node instanceof TextDefinition ) {

        tabPane.setSceneFactory( mDefinitionTabSceneFactory::create );

        index = 0;

      }

      addTabPane( index, 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();

        if( !(resource instanceof TextResource) ) {

          continue;

        }

        if( canClose( (TextResource) 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 ) {

        mHtmlPreview.setBaseUri( n.getPath() );

        process( n );

      }

    } );

    return editor;

  }

  /**

   * Adds the HTML preview tab to its own tab pane. This will only add the

   * preview once.

   */

  public void viewPreview() {

    final var tabPane = obtainDetachableTabPane( TEXT_HTML );

    // Prevent multiple HTML previews because in the end, there can be only one.

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

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

        return;

      }

    }

    tabPane.addTab( "HTML", mHtmlPreview );

    addTabPane( tabPane );

  }

  public void viewRefresh() {

    mHtmlPreview.refresh();

  }

  /**

   * Returns the tab that contains the given {@link TextEditor}.

   *

   * @param editor The {@link TextEditor} instance to find amongst the tabs.

   * @return The first tab having content that matches the given tab.

   */

  private Optional<Tab> getTab( final TextResource editor ) {

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

    enwrap( "\n\n```\n", "\n```\n\n" );

  @Override

      extensions.add( RExtension.create( rProcessor, context ) );

import com.vladsch.flexmark.ext.tables.TableBlock;

import static com.keenwrite.processors.markdown.extensions.r.EmptyNode.EMPTY_NODE;

    private boolean mAdded;

    private static AttributeProviderFactory createFactory( final Caret caret ) {

      // Optimization: if a caret is inserted, don't try to find another.

      if( mAdded ) {

        return;

      }

      // If a table block has been earmarked with an empty node, it means

      // another extension has generated code from an external source. The

      // Markdown processor won't be able to determine the caret position

      // with any semblance of accuracy, so skip the element. This usually

      // happens with tables, but in theory any Markdown generated from an

      // external source (e.g., an R script) could produce text that has no

      // caret position that can be calculated.

      var table = curr;

      if( !(curr instanceof TableBlock) ) {

        table = curr.getAncestorOfType( TableBlock.class );

      }

      // The table was generated outside the document

      if( table != null && table.getLastChild() == EMPTY_NODE ) {

        return;

      }

        // We're done until the user moves the caret (micro-optimization)

        mAdded = true;

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

package com.keenwrite.processors.markdown.extensions.r;

import com.vladsch.flexmark.util.ast.Node;

import com.vladsch.flexmark.util.sequence.BasedSequence;

import org.jetbrains.annotations.NotNull;

/**

 * The singleton is injected into the abstract syntax tree to mark an instance

 * of {@link Node} such that it must not be processed normally. Using a wrapper

 * for a given {@link Node} cannot work because the class type is used by

 * the parsing library for processing.

 */

public final class EmptyNode extends Node {

  public static final Node EMPTY_NODE = new EmptyNode();

  private static final BasedSequence[] BASE_SEQ = new BasedSequence[ 0 ];

  private EmptyNode() {

  }

  @Override

  public @NotNull BasedSequence[] getSegments() {

    return BASE_SEQ;

  }

}

import com.keenwrite.processors.ProcessorContext;

import com.keenwrite.processors.markdown.BaseMarkdownProcessor;

import com.vladsch.flexmark.ast.Paragraph;

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

import static com.keenwrite.processors.markdown.extensions.r.EmptyNode.EMPTY_NODE;

  private final BaseMarkdownProcessor mMarkdownProcessor;

  private RExtension(

    final RProcessor processor, final ProcessorContext context ) {

    mMarkdownProcessor = new BaseMarkdownProcessor( IDENTITY, context );

  public static RExtension create(

    final RProcessor processor, final ProcessorContext context ) {

    return new RExtension( processor, context );

            final var rText = mProcessor.apply( code );

            var node = mMarkdownProcessor.toNode( rText );

            if( node.getFirstChild() instanceof Paragraph ) {

              node = new Text( rText );

            }

            else {

              node = node.getFirstChild();

              if( node != null ) {

                // Mark the node as being generated code, such as text returned

                // from an R function.

                node.appendChild( EMPTY_NODE );

              }

            }

            blockNode.appendChild( node );

  private boolean mReady;

  }

  public boolean isReady() {

    return mReady;

  private static final char KEY_SEPARATOR_R = '$';

   * <p>

   * The algorithm to entoken a definition name is faster than

   * {@link String#replace(char, char)}. Faster still would be to cache the

   * values, but that would mean managing the cache when the user changes

   * the beginning and ending of the R delimiters. This code gives about a

   * 2% performance boost when scrolling using cursor keys. After the JIT

   * warms up, this super-minor bottleneck vanishes.

   * </p>

    final var detokened = new StringBuilder( key.length() );

    detokened.append( "v$" );

    detokened.append( mAntecedent.detoken( key ) );

    // The 3 is for "v$X" where X cannot be a period.

    for( int i = detokened.length() - 1; i >= 3; i-- ) {

      if( detokened.charAt( i ) == KEY_SEPARATOR_DEF ) {

        detokened.setCharAt( i, KEY_SEPARATOR_R );

      }

    }

    return detokened.toString();

    final var window = getDialogPane().getScene().getWindow();

import static com.keenwrite.StatusNotifier.clue;

    clue();

workspace.images.dir=Absolute Directory

workspace.images.dir.desc=Path to search for local file system images.