AbstractTimeLineView.java

Go to the documentation of this file.

/*
 * Autopsy Forensic Browser
 *
 * Copyright 2011-2018 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.collect.ImmutableList;
import com.google.common.eventbus.Subscribe;
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.ReadOnlyBooleanProperty;
import javafx.beans.property.ReadOnlyBooleanWrapper;
import javafx.concurrent.Task;
import javafx.scene.Cursor;
import javafx.scene.Node;
import javafx.scene.layout.BorderPane;
import javafx.scene.layout.StackPane;
import org.controlsfx.control.MaskerPane;
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.EventsModel;
import org.sleuthkit.autopsy.timeline.TimeLineController;
import org.sleuthkit.autopsy.timeline.ViewMode;
import org.sleuthkit.autopsy.timeline.events.RefreshRequestedEvent;

public abstract class AbstractTimeLineView extends BorderPane {
 
    private static final Logger logger = Logger.getLogger(AbstractTimeLineView.class.getName());

    private final ReadOnlyBooleanWrapper hasVisibleEvents = new ReadOnlyBooleanWrapper(true);

    private final ReadOnlyBooleanWrapper needsRefresh = new ReadOnlyBooleanWrapper(false);

    private InvalidationListener updateListener = (Observable any) -> refresh();

    private Task<Boolean> updateTask;
 
    private final TimeLineController controller;
    private final EventsModel filteredEvents;

    public AbstractTimeLineView(TimeLineController controller) {
        this.controller = controller;
        this.filteredEvents = controller.getEventsModel();
        this.filteredEvents.registerForEvents(this);
        this.filteredEvents.modelParamsProperty().addListener(updateListener);
        TimeLineController.timeZoneProperty().addListener(updateListener);
    }

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

    public boolean needsRefresh() {
        return needsRefresh.get();
    }

    public ReadOnlyBooleanProperty needsRefreshProperty() {
        return needsRefresh.getReadOnlyProperty();
    }

    protected TimeLineController getController() {
        return controller;
    }

    protected final synchronized void refresh() {
        if (updateTask != null) {
            updateTask.cancel(true);
            updateTask = null;
        }
        updateTask = getNewUpdateTask();
        updateTask.stateProperty().addListener((Observable observable) -> {
            switch (updateTask.getState()) {
                case CANCELLED:
                case FAILED:
                case READY:
                case RUNNING:
                case SCHEDULED:
                    break;
                case SUCCEEDED:
                    try {
                        this.hasVisibleEvents.set(updateTask.get());
                    } catch (InterruptedException | ExecutionException ex) {
                        logger.log(Level.SEVERE, "Unexpected exception updating view", ex); //NON-NLS
                    }
                    break;
            }
        });
        getController().monitorTask(updateTask);
    }

    protected EventsModel getEventsModel() {
        return filteredEvents;
    }

    protected abstract Task<Boolean> getNewUpdateTask();

    protected abstract ViewMode getViewMode();

    abstract protected ImmutableList<Node> getSettingsControls();

    abstract protected boolean hasCustomTimeNavigationControls();

    abstract protected ImmutableList<Node> getTimeNavigationControls();

    final synchronized void dispose() {
        //cancel and gc updateTask
        if (updateTask != null) {
            updateTask.cancel(true);
            updateTask = null;
        }
        //remvoe and gc updateListener
        this.filteredEvents.modelParamsProperty().removeListener(updateListener);
        TimeLineController.timeZoneProperty().removeListener(updateListener);
        updateListener = null;
        filteredEvents.unRegisterForEvents(this);
        controller.unRegisterForEvents(this);
    }

    boolean hasVisibleEvents() {
        return hasVisibleEventsProperty().get();
    }

    ReadOnlyBooleanProperty hasVisibleEventsProperty() {
        return hasVisibleEvents.getReadOnlyProperty();
    }

    void setNeedsRefresh() {
        needsRefresh.set(true);
    }

    @ThreadConfined(type = ThreadConfined.ThreadType.JFX)
    abstract protected void clearData();

    protected abstract class ViewRefreshTask<AxisValuesType> extends LoggedTask<Boolean> {
 
        private final Node center;

        protected ViewRefreshTask(String taskName, boolean logStateChanges) {
            super(taskName, logStateChanges);
            this.center = getCenter();
        }

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

        @Override
        protected void succeeded() {
            super.succeeded();
            needsRefresh.set(false);
            cleanup();
        }

        @Override
        protected void cancelled() {
            super.cancelled();
            cleanup();
        }

        @Override
        protected void failed() {
            super.failed();
            cleanup();
        }

        private void cleanup() {
            setCenter(center); //clear masker pane installed in call()
            setCursor(Cursor.DEFAULT);
        }

        protected abstract void setDateValues(AxisValuesType values);

        @ThreadConfined(type = ThreadConfined.ThreadType.NOT_UI)
        protected void resetView(AxisValuesType axisValues) {
            Platform.runLater(() -> {
                clearData();
                setDateValues(axisValues);
            });
        }
    }
}