AbstractVisualizationPane.java

Go to the documentation of this file.

/*
 * Autopsy Forensic Browser
 *
 * Copyright 2014-15 Basis Technology Corp.
 * Contact: carrier <at> sleuthkit <dot> org
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.sleuthkit.autopsy.timeline.ui;

import com.google.common.eventbus.Subscribe;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ExecutionException;
import java.util.logging.Level;
import javafx.application.Platform;
import javafx.beans.InvalidationListener;
import javafx.beans.Observable;
import javafx.beans.property.SimpleBooleanProperty;
import javafx.collections.FXCollections;
import javafx.collections.ListChangeListener;
import javafx.collections.ObservableList;
import javafx.concurrent.Service;
import javafx.concurrent.Task;
import javafx.geometry.Pos;
import javafx.scene.Cursor;
import javafx.scene.Node;
import javafx.scene.chart.Axis;
import javafx.scene.chart.Chart;
import javafx.scene.chart.XYChart;
import javafx.scene.control.Label;
import javafx.scene.control.OverrunStyle;
import javafx.scene.control.Tooltip;
import javafx.scene.effect.Effect;
import javafx.scene.input.MouseButton;
import javafx.scene.input.MouseEvent;
import javafx.scene.layout.BorderPane;
import javafx.scene.layout.Pane;
import javafx.scene.layout.Region;
import javafx.scene.layout.StackPane;
import javafx.scene.text.Font;
import javafx.scene.text.FontWeight;
import javafx.scene.text.Text;
import javafx.scene.text.TextAlignment;
import javax.annotation.concurrent.Immutable;
import org.apache.commons.lang3.StringUtils;
import org.controlsfx.control.MaskerPane;
import org.joda.time.Interval;
import org.openide.util.NbBundle;
import org.sleuthkit.autopsy.coreutils.LoggedTask;
import org.sleuthkit.autopsy.coreutils.Logger;
import org.sleuthkit.autopsy.coreutils.ThreadConfined;
import org.sleuthkit.autopsy.timeline.TimeLineController;
import org.sleuthkit.autopsy.timeline.datamodel.FilteredEventsModel;
import org.sleuthkit.autopsy.timeline.datamodel.eventtype.EventType;
import org.sleuthkit.autopsy.timeline.events.RefreshRequestedEvent;

public abstract class AbstractVisualizationPane<X, Y, NodeType extends Node, ChartType extends XYChart<X, Y> & TimeLineChart<X>> extends BorderPane {

    @NbBundle.Messages("AbstractVisualization.Default_Tooltip.text=Drag the mouse to select a time interval to zoom into.\nRight-click for more actions.")
    private static final Tooltip DEFAULT_TOOLTIP = new Tooltip(Bundle.AbstractVisualization_Default_Tooltip_text());
    private static final Logger LOGGER = Logger.getLogger(AbstractVisualizationPane.class.getName());

    public static Tooltip getDefaultTooltip() {
        return DEFAULT_TOOLTIP;
    }

    protected final SimpleBooleanProperty hasEvents = new SimpleBooleanProperty(true);

    protected final ObservableList<XYChart.Series<X, Y>> dataSeries = FXCollections.<XYChart.Series<X, Y>>observableArrayList();
    protected final Map<EventType, XYChart.Series<X, Y>> eventTypeToSeriesMap = new HashMap<>();

    protected ChartType chart;

    private final Pane leafPane; // container for the leaf lables in the declutterd axis
    private final Pane branchPane;// container for the branch lables in the declutterd axis
    protected final Region spacer;

    private Task<Boolean> updateTask;

    final protected TimeLineController controller;

    final protected FilteredEventsModel filteredEvents;

    final protected ObservableList<NodeType> selectedNodes = FXCollections.observableArrayList();

    private InvalidationListener invalidationListener = (Observable observable) -> {
        update();
    };

    public ObservableList<NodeType> getSelectedNodes() {
        return selectedNodes;
    }

    protected List<Node> settingsNodes;

    protected List<Node> getSettingsNodes() {
        return Collections.unmodifiableList(settingsNodes);
    }

    abstract protected Boolean isTickBold(X value);

    abstract protected void applySelectionEffect(NodeType node, Boolean applied);

    abstract protected Task<Boolean> getUpdateTask();

    abstract protected Effect getSelectionEffect();

    abstract protected String getTickMarkLabel(X tickValue);

    abstract protected double getTickSpacing();

    abstract protected Axis<X> getXAxis();

    abstract protected Axis<Y> getYAxis();

    abstract protected void resetData();

    final synchronized public void update() {
        if (updateTask != null) {
            updateTask.cancel(true);
            updateTask = null;
        }
        updateTask = getUpdateTask();
        updateTask.stateProperty().addListener((Observable observable) -> {
            switch (updateTask.getState()) {
                case CANCELLED:
                case FAILED:
                case READY:
                case RUNNING:
                case SCHEDULED:
                    break;
                case SUCCEEDED:
                    try {
                        this.hasEvents.set(updateTask.get());
                    } catch (InterruptedException | ExecutionException ex) {
                        LOGGER.log(Level.SEVERE, "Unexpected exception updating visualization", ex); //NOI18N NON-NLS
                    }
                    break;
            }
        });
        controller.monitorTask(updateTask);
    }

    final synchronized public void dispose() {
        if (updateTask != null) {
            updateTask.cancel(true);
        }
        this.filteredEvents.zoomParametersProperty().removeListener(invalidationListener);
        invalidationListener = null;
    }

    protected final void createSeries() {
        for (EventType eventType : EventType.allTypes) {
            XYChart.Series<X, Y> series = new XYChart.Series<>();
            series.setName(eventType.getDisplayName());
            eventTypeToSeriesMap.put(eventType, series);
            dataSeries.add(series);
        }
    }

    protected final XYChart.Series<X, Y> getSeries(final EventType et) {
        return eventTypeToSeriesMap.get(et);
    }

    protected AbstractVisualizationPane(TimeLineController controller, Pane partPane, Pane contextPane, Region spacer) {
        this.controller = controller;
        this.filteredEvents = controller.getEventsModel();
        this.filteredEvents.registerForEvents(this);
        this.filteredEvents.zoomParametersProperty().addListener(invalidationListener);
        this.leafPane = partPane;
        this.branchPane = contextPane;
        this.spacer = spacer;

        createSeries();

        selectedNodes.addListener((ListChangeListener.Change<? extends NodeType> c) -> {
            while (c.next()) {
                c.getRemoved().forEach(n -> applySelectionEffect(n, false));
                c.getAddedSubList().forEach(n -> applySelectionEffect(n, true));
            }
        });

        TimeLineController.getTimeZone().addListener(invalidationListener);

        //show tooltip text in status bar
        hoverProperty().addListener(observable -> controller.setStatus(isHover() ? DEFAULT_TOOLTIP.getText() : ""));

    }

    @Subscribe
    public void handleRefreshRequested(RefreshRequestedEvent event) {
        update();
    }

    @ThreadConfined(type = ThreadConfined.ThreadType.JFX)
    public synchronized void layoutDateLabels() {

        //clear old labels
        branchPane.getChildren().clear();
        leafPane.getChildren().clear();
        //since the tickmarks aren't necessarily in value/position order,
        //make a clone of the list sorted by position along axis
        ObservableList<Axis.TickMark<X>> tickMarks = FXCollections.observableArrayList(getXAxis().getTickMarks());
        tickMarks.sort(Comparator.comparing(Axis.TickMark::getPosition));

        if (tickMarks.isEmpty() == false) {
            //get the spacing between ticks in the underlying axis
            double spacing = getTickSpacing();

            //initialize values from first tick
            TwoPartDateTime dateTime = new TwoPartDateTime(getTickMarkLabel(tickMarks.get(0).getValue()));
            String lastSeenBranchLabel = dateTime.branch;
            //cumulative width of the current branch label

            //x-positions (pixels) of the current branch and leaf labels
            double leafLabelX = 0;

            if (dateTime.branch.isEmpty()) {
                //if there is only one part to the date (ie only year), just add a label for each tick
                for (Axis.TickMark<X> t : tickMarks) {
                    assignLeafLabel(new TwoPartDateTime(getTickMarkLabel(t.getValue())).leaf,
                            spacing,
                            leafLabelX,
                            isTickBold(t.getValue())
                    );

                    leafLabelX += spacing;  //increment x
                }
            } else {
                //there are two parts so ...
                //initialize additional state
                double branchLabelX = 0;
                double branchLabelWidth = 0;

                for (Axis.TickMark<X> t : tickMarks) {               //for each tick

                    //split the label into a TwoPartDateTime
                    dateTime = new TwoPartDateTime(getTickMarkLabel(t.getValue()));

                    //if we are still on the same branch
                    if (lastSeenBranchLabel.equals(dateTime.branch)) {
                        //increment branch width
                        branchLabelWidth += spacing;
                    } else {// we are on to a new branch, so ...
                        assignBranchLabel(lastSeenBranchLabel, branchLabelWidth, branchLabelX);
                        //and then update label, x-pos, and width
                        lastSeenBranchLabel = dateTime.branch;
                        branchLabelX += branchLabelWidth;
                        branchLabelWidth = spacing;
                    }
                    //add the label for the leaf (highest frequency part)
                    assignLeafLabel(dateTime.leaf, spacing, leafLabelX, isTickBold(t.getValue()));

                    //increment leaf position
                    leafLabelX += spacing;
                }
                //we have reached end so add branch label for current branch
                assignBranchLabel(lastSeenBranchLabel, branchLabelWidth, branchLabelX);
            }
        }
        //request layout since we have modified scene graph structure
        requestParentLayout();
    }

    protected void setChartClickHandler() {
        chart.addEventHandler(MouseEvent.MOUSE_CLICKED, (MouseEvent event) -> {
            if (event.getButton() == MouseButton.PRIMARY && event.isStillSincePress()) {
                selectedNodes.clear();
            }
        });
    }

    private synchronized void assignLeafLabel(String labelText, double labelWidth, double labelX, boolean bold) {

        Text label = new Text(" " + labelText + " "); //NOI18N
        label.setTextAlignment(TextAlignment.CENTER);
        label.setFont(Font.font(null, bold ? FontWeight.BOLD : FontWeight.NORMAL, 10));
        //position label accounting for width
        label.relocate(labelX + labelWidth / 2 - label.getBoundsInLocal().getWidth() / 2, 0);
        label.autosize();

        if (leafPane.getChildren().isEmpty()) {
            //just add first label
            leafPane.getChildren().add(label);
        } else {
            //otherwise don't actually add the label if it would intersect with previous label
            final Text lastLabel = (Text) leafPane.getChildren().get(leafPane.getChildren().size() - 1);

            if (!lastLabel.getBoundsInParent().intersects(label.getBoundsInParent())) {
                leafPane.getChildren().add(label);
            }
        }
    }

    private synchronized void assignBranchLabel(String labelText, double labelWidth, double labelX) {

        Label label = new Label(labelText);
        label.setAlignment(Pos.CENTER);
        label.setTextAlignment(TextAlignment.CENTER);
        label.setFont(Font.font(10));
        //use a leading ellipse since that is the lowest frequency part,
        //and can be infered more easily from other surrounding labels
        label.setTextOverrun(OverrunStyle.LEADING_ELLIPSIS);
        //force size
        label.setMinWidth(labelWidth);
        label.setPrefWidth(labelWidth);
        label.setMaxWidth(labelWidth);
        label.relocate(labelX, 0);

        if (labelX == 0) { // first label has no border
            label.setStyle("-fx-border-width: 0 0 0 0 ; -fx-border-color:black;"); // NON-NLS //NOI18N
        } else {  // subsequent labels have border on left to create dividers
            label.setStyle("-fx-border-width: 0 0 0 1; -fx-border-color:black;"); // NON-NLS //NOI18N
        }

        branchPane.getChildren().add(label);
    }

    @Immutable
    private static final class TwoPartDateTime {

        private final String branch;

        private final String leaf;

        TwoPartDateTime(String dateString) {
            //find index of separator to spit on
            int splitIndex = StringUtils.lastIndexOfAny(dateString, " ", "-", ":"); //NOI18N
            if (splitIndex < 0) { // there is only one part
                leaf = dateString;
                branch = ""; //NOI18N
            } else { //split at index
                leaf = StringUtils.substring(dateString, splitIndex + 1);
                branch = StringUtils.substring(dateString, 0, splitIndex);
            }
        }
    }

    protected Interval getTimeRange() {
        return filteredEvents.timeRangeProperty().get();
    }

    abstract protected class VisualizationUpdateTask<AxisValuesType> extends LoggedTask<Boolean> {

        protected VisualizationUpdateTask(String taskName, boolean logStateChanges) {
            super(taskName, logStateChanges);
        }

        @NbBundle.Messages({"VisualizationUpdateTask.preparing=Analyzing zoom and filter settings"})
        @Override
        protected Boolean call() throws Exception {
            updateProgress(-1, 1);
            updateMessage(Bundle.VisualizationUpdateTask_preparing());
            Platform.runLater(() -> {
                MaskerPane maskerPane = new MaskerPane();
                maskerPane.textProperty().bind(messageProperty());
                maskerPane.progressProperty().bind(progressProperty());
                setCenter(new StackPane(chart, maskerPane));
                setCursor(Cursor.WAIT);
            });

            return true;
        }

        @Override
        protected void succeeded() {
            super.succeeded();
            layoutDateLabels();

            Platform.runLater(() -> {
                setCenter(chart); //clear masker pane
                setCursor(Cursor.DEFAULT);
            });
        }

        @ThreadConfined(type = ThreadConfined.ThreadType.NOT_UI)
        protected void resetChart(AxisValuesType axisValues) {
            resetData();
            Platform.runLater(() -> {
                setDateAxisValues(axisValues);
            });

        }

        abstract protected void setDateAxisValues(AxisValuesType values);
    }
}