DataResultPanel.java

Go to the documentation of this file.

/*
 * Autopsy Forensic Browser
 *
 * Copyright 2013-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.corecomponents;

import java.awt.Cursor;
import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import javax.swing.JTabbedPane;
import javax.swing.SwingUtilities;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;
import org.openide.explorer.ExplorerManager;
import org.openide.nodes.Node;
import org.openide.nodes.NodeEvent;
import org.openide.nodes.NodeListener;
import org.openide.nodes.NodeMemberEvent;
import org.openide.nodes.NodeReorderEvent;
import org.openide.util.Lookup;
import org.openide.util.NbBundle;
import org.sleuthkit.autopsy.casemodule.Case;
import org.sleuthkit.autopsy.casemodule.NoCurrentCaseException;
import org.sleuthkit.autopsy.corecomponentinterfaces.DataContent;
import org.sleuthkit.autopsy.corecomponentinterfaces.DataResult;
import org.sleuthkit.autopsy.corecomponentinterfaces.DataResultViewer;
import org.sleuthkit.autopsy.datamodel.NodeSelectionInfo;

@SuppressWarnings("PMD.SingularField") // UI widgets cause lots of false positives
public class DataResultPanel extends javax.swing.JPanel implements DataResult, ChangeListener, ExplorerManager.Provider {

    private static final long serialVersionUID = 1L;
    private static final int NO_TAB_SELECTED = -1;
    private static final String PLEASE_WAIT_NODE_DISPLAY_NAME = NbBundle.getMessage(DataResultPanel.class, "DataResultPanel.pleasewaitNodeDisplayName");
    private final boolean isMain;
    private final List<DataResultViewer> resultViewers;
    private final ExplorerManagerListener explorerManagerListener;
    private final RootNodeListener rootNodeListener;
    private DataContent contentView;
    private ExplorerManager explorerManager;
    private Node currentRootNode;
    private boolean listeningToTabbedPane;

    public static DataResultPanel createInstance(String title, String description, Node currentRootNode, int childNodeCount) {
        DataResultPanel resultPanel = new DataResultPanel(title, false, Collections.emptyList(), DataContentTopComponent.findInstance());
        createInstanceCommon(title, description, currentRootNode, childNodeCount, resultPanel);
        resultPanel.open();
        return resultPanel;
    }

    public static DataResultPanel createInstance(String title, String description, Node currentRootNode, int childNodeCount, Collection<DataResultViewer> viewers) {
        DataResultPanel resultPanel = new DataResultPanel(title, false, viewers, DataContentTopComponent.findInstance());
        createInstanceCommon(title, description, currentRootNode, childNodeCount, resultPanel);
        resultPanel.open();
        return resultPanel;
    }

    public static DataResultPanel createInstance(String title, String description, Node currentRootNode, int childNodeCount, DataContent customContentView) {
        DataResultPanel resultPanel = new DataResultPanel(title, false, Collections.emptyList(), customContentView);
        createInstanceCommon(title, description, currentRootNode, childNodeCount, resultPanel);
        resultPanel.open();
        return resultPanel;
    }

    public static DataResultPanel createInstanceUninitialized(String title, String description, Node currentRootNode, int childNodeCount, DataContent customContentView) {
        DataResultPanel resultPanel = new DataResultPanel(title, false, Collections.emptyList(), customContentView);
        createInstanceCommon(title, description, currentRootNode, childNodeCount, resultPanel);
        return resultPanel;
    }

    private static void createInstanceCommon(String title, String description, Node currentRootNode, int childNodeCount, DataResultPanel resultViewPanel) {
        resultViewPanel.setTitle(title);
        resultViewPanel.setName(title);
        resultViewPanel.setNumberOfChildNodes(childNodeCount);
        resultViewPanel.setNode(currentRootNode);
        resultViewPanel.setPath(description);
    }

    DataResultPanel(String title, boolean isMain, Collection<DataResultViewer> viewers, DataContent contentView) {
        this.setTitle(title);
        this.isMain = isMain;
        this.contentView = contentView;
        this.resultViewers = new ArrayList<>(viewers);
        this.explorerManagerListener = new ExplorerManagerListener();
        this.rootNodeListener = new RootNodeListener();
        initComponents();
    }

    @Override
    public String getPreferredID() {
        return getName();
    }

    @Override
    public void setTitle(String title) {
        setName(title);
    }

    @Override
    public void setPath(String description) {
        this.descriptionLabel.setText(description);
    }

    public void addResultViewer(DataResultViewer resultViewer) {
        resultViewers.add(resultViewer);
        resultViewerTabs.addTab(resultViewer.getTitle(), resultViewer.getComponent());
    }

    @Override
    public List<DataResultViewer> getViewers() {
        return Collections.unmodifiableList(resultViewers);
    }

    public void setContentViewer(DataContent customContentView) {
        this.contentView = customContentView;
    }

    public void open() {
        /*
         * The parent top component is expected to be an explorer manager
         * provider that exposes a lookup maintained by its explorer manager to
         * the actions global context. The child result view panel will then
         * find the parent top component's explorer manager at runtime, so that
         * it can act as an explorer manager provider for its child result
         * viewers. This connects the nodes displayed in the result viewers to
         * the actions global context.
         */
        if (this.explorerManager == null) {
            this.explorerManager = ExplorerManager.find(this);
            this.explorerManager.addPropertyChangeListener(this.explorerManagerListener);
        }

        /*
         * Load either the supplied result viewers or the result viewers
         * provided by the result viewer extension point into the tabbed pane.
         * If loading from the extension point and distinct result viewer
         * instances MUST be created if this is not the "main" result view.
         */
        if (this.resultViewerTabs.getTabCount() == 0) {
            if (this.resultViewers.isEmpty()) {
                for (DataResultViewer resultViewer : Lookup.getDefault().lookupAll(DataResultViewer.class)) {
                    if (this.isMain) {
                        this.resultViewers.add(resultViewer);
                    } else {
                        this.resultViewers.add(resultViewer.createInstance());
                    }
                }
            }
            this.resultViewers.forEach((resultViewer) -> resultViewerTabs.addTab(resultViewer.getTitle(), resultViewer.getComponent()));
        }

        this.setVisible(true);
    }

    @Override
    public void setNode(Node rootNode) {
        if (this.currentRootNode != null) {
            this.currentRootNode.removeNodeListener(rootNodeListener);
        }

        /*
         * Deferring becoming a listener to the tabbed pane until this point
         * eliminates handling a superfluous stateChanged event during
         * construction.
         */
        if (listeningToTabbedPane == false) {
            resultViewerTabs.addChangeListener(this);
            listeningToTabbedPane = true;
        }

        this.currentRootNode = rootNode;
        if (this.currentRootNode != null) {
            /*
             * The only place we reset the rootNodeListener allowing the
             * contents of the results tab represented by this node to be
             * changed a single time before it is necessary to reset it again.
             * Necessary when transitioning from "Please wait..." node to having
             * contents.
             */
            rootNodeListener.reset();
            this.currentRootNode.addNodeListener(rootNodeListener);
        }

        this.resultViewers.forEach((viewer) -> {
            viewer.resetComponent();
        });
        setupTabs(this.currentRootNode);

        if (this.currentRootNode != null) {
            int childrenCount = this.currentRootNode.getChildren().getNodesCount();
            this.numberOfChildNodesLabel.setText(Integer.toString(childrenCount));
        }
        this.numberOfChildNodesLabel.setVisible(true);
    }

    public Node getRootNode() {
        return currentRootNode;
    }

    public void setNumberOfChildNodes(Integer numberOfChildNodes) {
        this.numberOfChildNodesLabel.setText(Integer.toString(numberOfChildNodes));
    }

    public void setSelectedNodes(Node[] selectedNodes) {
        this.resultViewers.forEach((viewer) -> viewer.setSelectedNodes(selectedNodes));
    }

    private void setupTabs(Node selectedNode) {
        /*
         * Enable or disable the result viewer tabs based on whether or not the
         * corresponding results viewer supports display of the selected node.
         */
        for (int i = 0; i < resultViewerTabs.getTabCount(); i++) {
            if (resultViewers.get(i).isSupported(selectedNode)) {
                resultViewerTabs.setEnabledAt(i, true);
            } else {
                resultViewerTabs.setEnabledAt(i, false);
            }
        }

        /*
         * If the selected node has a child to be selected, default the selected
         * tab to the table result viewer. Otherwise, use the last selected tab,
         * if it is enabled. If not, select the first enabled tab that can be
         * found.
         */
        int tabToSelect = NO_TAB_SELECTED;
        if (selectedNode instanceof TableFilterNode) {
            NodeSelectionInfo selectedChildInfo = ((TableFilterNode) selectedNode).getChildNodeSelectionInfo();
            if (null != selectedChildInfo) {
                for (int i = 0; i < resultViewers.size(); ++i) {
                    if (resultViewers.get(i) instanceof DataResultViewerTable && resultViewerTabs.isEnabledAt(i)) {
                        tabToSelect = i;
                    }
                }
            }
        }
        if (tabToSelect == NO_TAB_SELECTED) {
            if ((tabToSelect == NO_TAB_SELECTED) || (!resultViewerTabs.isEnabledAt(tabToSelect))) {
                for (int i = 0; i < resultViewerTabs.getTabCount(); ++i) {
                    if (resultViewerTabs.isEnabledAt(i)) {
                        tabToSelect = i;
                        break;
                    }
                }
            }
        }

        /*
         * If there is a tab to select, do so, and push the selected node to the
         * corresponding result viewer.
         */
        if (tabToSelect != NO_TAB_SELECTED) {
            resultViewerTabs.setSelectedIndex(tabToSelect);
            resultViewers.get(tabToSelect).setNode(selectedNode);
        }
    }

    @Override
    public void stateChanged(ChangeEvent event) {
        JTabbedPane pane = (JTabbedPane) event.getSource();
        int currentTab = pane.getSelectedIndex();
        if (currentTab != DataResultPanel.NO_TAB_SELECTED) {
            DataResultViewer currentViewer = this.resultViewers.get(currentTab);
            this.setCursor(Cursor.getPredefinedCursor(Cursor.WAIT_CURSOR));
            try {
                currentViewer.setNode(currentRootNode);
            } finally {
                this.setCursor(Cursor.getPredefinedCursor(Cursor.DEFAULT_CURSOR));
            }
        }
    }

    public boolean canClose() {
        /*
         * If this is the "main" panel, only allow it to be closed when no case
         * is open or no there are no data sources in the current case.
         */
        Case openCase;
        try {
            openCase = Case.getCurrentCaseThrows();
        } catch (NoCurrentCaseException ex) {
            return true;
        }
        return (!this.isMain) || openCase.hasData() == false;
    }

    void close() {
        if (explorerManager != null && explorerManagerListener != null) {
            explorerManager.removePropertyChangeListener(explorerManagerListener);
            explorerManager = null;
        }

        this.resultViewers.forEach((viewer) -> viewer.setNode(null));

        if (!this.isMain) {
            this.resultViewers.forEach(DataResultViewer::clearComponent);
            this.descriptionLabel.removeAll();
            this.numberOfChildNodesLabel.removeAll();
            this.matchLabel.removeAll();
            this.setLayout(null);
            this.removeAll();
            this.setVisible(false);
        }
    }

    @Override
    public ExplorerManager getExplorerManager() {
        return explorerManager;

    }

    private class ExplorerManagerListener implements PropertyChangeListener {

        @Override
        public void propertyChange(PropertyChangeEvent evt) {
            if (evt.getPropertyName().equals(ExplorerManager.PROP_SELECTED_NODES) && contentView != null) {
                /*
                 * Pass a single node selection in a result viewer to the
                 * content view. Note that passing null to the content view
                 * signals that either multiple nodes are selected, or a
                 * previous selection has been cleared. This is important to the
                 * content view, since its child content viewers only work for a
                 * single node.
                 */
                Node[] selectedNodes = explorerManager.getSelectedNodes();
                if (selectedNodes.length == 1) {
                    contentView.setNode(selectedNodes[0]);
                } else {
                    contentView.setNode(null);
                }
            }
        }
    }

    private class RootNodeListener implements NodeListener {

        //it is assumed we are still waiting for data when the node is initially constructed
        private volatile boolean waitingForData = true;

        public void reset() {
            waitingForData = true;
        }

        @Override
        public void childrenAdded(final NodeMemberEvent nme) {
            Node[] delta = nme.getDelta();
            updateMatches();

            /*
             * Ensures that after the initial call to setupTabs in the
             * DataResultPanel.setNode method that we only call setupTabs one
             * additional time. This is to account for the transition that is
             * possible from a "Please wait..." node or a tab with no results in
             * it and a tab containing data and thereby having all of it's
             * columns.
             */
            if (waitingForData && containsReal(delta)) {
                waitingForData = false;
                if (SwingUtilities.isEventDispatchThread()) {
                    setupTabs(nme.getNode());
                } else {
                    SwingUtilities.invokeLater(() -> {
                        setupTabs(nme.getNode());
                    });
                }
            }
        }

        private boolean containsReal(Node[] delta) {
            for (Node n : delta) {
                if (!n.getDisplayName().equals(PLEASE_WAIT_NODE_DISPLAY_NAME)) {
                    return true;
                }
            }
            return false;
        }

        private void updateMatches() {
            if (currentRootNode != null && currentRootNode.getChildren() != null) {
                setNumMatches(currentRootNode.getChildren().getNodesCount());
            }
        }

        @Override
        public void childrenRemoved(NodeMemberEvent nme) {
            updateMatches();
        }

        @Override
        public void childrenReordered(NodeReorderEvent nre) {
        }

        @Override
        public void nodeDestroyed(NodeEvent ne) {
        }

        @Override
        public void propertyChange(PropertyChangeEvent evt) {
        }
    }

    @SuppressWarnings("unchecked")
    // <editor-fold defaultstate="collapsed" desc="Generated Code">//GEN-BEGIN:initComponents
    private void initComponents() {

        descriptionLabel = new javax.swing.JLabel();
        numberOfChildNodesLabel = new javax.swing.JLabel();
        matchLabel = new javax.swing.JLabel();
        resultViewerTabs = new javax.swing.JTabbedPane();

        setMinimumSize(new java.awt.Dimension(0, 5));
        setPreferredSize(new java.awt.Dimension(5, 5));

        org.openide.awt.Mnemonics.setLocalizedText(descriptionLabel, org.openide.util.NbBundle.getMessage(DataResultPanel.class, "DataResultPanel.descriptionLabel.text")); // NOI18N
        descriptionLabel.setMinimumSize(new java.awt.Dimension(5, 14));

        org.openide.awt.Mnemonics.setLocalizedText(numberOfChildNodesLabel, org.openide.util.NbBundle.getMessage(DataResultPanel.class, "DataResultPanel.numberOfChildNodesLabel.text")); // NOI18N

        org.openide.awt.Mnemonics.setLocalizedText(matchLabel, org.openide.util.NbBundle.getMessage(DataResultPanel.class, "DataResultPanel.matchLabel.text")); // NOI18N

        resultViewerTabs.setMinimumSize(new java.awt.Dimension(0, 5));

        javax.swing.GroupLayout layout = new javax.swing.GroupLayout(this);
        this.setLayout(layout);
        layout.setHorizontalGroup(
            layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
            .addGroup(layout.createSequentialGroup()
                .addComponent(descriptionLabel, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
                .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)
                .addComponent(numberOfChildNodesLabel)
                .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
                .addComponent(matchLabel))
            .addComponent(resultViewerTabs, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)
        );
        layout.setVerticalGroup(
            layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
            .addGroup(layout.createSequentialGroup()
                .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
                    .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
                        .addComponent(numberOfChildNodesLabel)
                        .addComponent(matchLabel))
                    .addComponent(descriptionLabel, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE))
                .addGap(0, 0, 0)
                .addComponent(resultViewerTabs, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE))
        );
    }// </editor-fold>//GEN-END:initComponents
    // Variables declaration - do not modify//GEN-BEGIN:variables
    private javax.swing.JLabel descriptionLabel;
    private javax.swing.JLabel matchLabel;
    private javax.swing.JLabel numberOfChildNodesLabel;
    private javax.swing.JTabbedPane resultViewerTabs;
    // End of variables declaration//GEN-END:variables

    @Deprecated
    @Override
    public boolean isMain() {
        return this.isMain;
    }

    @Deprecated
    public void setNumMatches(Integer numberOfChildNodes) {
        this.setNumberOfChildNodes(numberOfChildNodes);
    }

    @Deprecated
    public void resetTabs(Node unusedSelectedNode) {
        this.setNode(null);
    }

}