DataResultPanel.java

Go to the documentation of this file.

/*
 * Autopsy Forensic Browser
 *
 * Copyright 2011-2017 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.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.corecomponentinterfaces.DataContent;
import org.sleuthkit.autopsy.corecomponentinterfaces.DataResult;
import org.sleuthkit.autopsy.corecomponentinterfaces.DataResultViewer;
import org.sleuthkit.autopsy.datamodel.NodeSelectionInfo;

public class DataResultPanel extends javax.swing.JPanel implements DataResult, ChangeListener {

    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 List<DataResultViewer> resultViewers = new ArrayList<>();
    private boolean isMain;
    private ExplorerManager explorerManager;
    private ExplorerManagerNodeSelectionListener emNodeSelectionListener;
    private Node rootNode;
    private final RootNodeListener rootNodeListener = new RootNodeListener();
    private boolean listeningToTabbedPane;
    private DataContent contentView;

    public static DataResultPanel createInstance(String title, String pathText, Node rootNode, int totalMatches) {
        DataResultPanel resultPanel = new DataResultPanel(title, false);
        createInstanceCommon(title, pathText, rootNode, totalMatches, resultPanel);
        resultPanel.open();
        return resultPanel;
    }

    public static DataResultPanel createInstance(String title, String pathText, Node rootNode, int totalMatches, DataContent customContentView) {
        DataResultPanel resultPanel = new DataResultPanel(title, customContentView);
        createInstanceCommon(title, pathText, rootNode, totalMatches, resultPanel);
        resultPanel.open();
        return resultPanel;
    }

    public static DataResultPanel createInstanceUninitialized(String title, String pathText, Node rootNode, int totalMatches, DataContent customContentView) {
        DataResultPanel resultPanel = new DataResultPanel(title, customContentView);
        createInstanceCommon(title, pathText, rootNode, totalMatches, resultPanel);
        return resultPanel;
    }

    private static void createInstanceCommon(String title, String pathText, Node rootNode, int totalMatches, DataResultPanel resultViewPanel) {
        resultViewPanel.setTitle(title);
        resultViewPanel.setName(title);
        resultViewPanel.setNumMatches(totalMatches);
        resultViewPanel.setNode(rootNode);
        resultViewPanel.setPath(pathText);
    }

    private DataResultPanel() {
        this.isMain = true;
        initComponents();
    }

    DataResultPanel(String title, boolean isMain) {
        this();
        this.isMain = isMain;
        this.contentView = Lookup.getDefault().lookup(DataContent.class);
    }

    DataResultPanel(String title, DataContent customContentView) {
        this(title, false);
        this.contentView = customContentView;
    }

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

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

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

    @Override
    public void setPath(String pathText) {
        this.directoryTablePath.setText(pathText);
    }

    private void addResultViewer(DataResultViewer resultViewer) {
        if (null != contentView) {
            resultViewer.setContentViewer(contentView);
        }
        resultViewers.add(resultViewer);
        dataResultTabbedPanel.addTab(resultViewer.getTitle(), resultViewer.getComponent());
    }

    @Override
    public List<DataResultViewer> getViewers() {
        List<DataResultViewer> viewers = new ArrayList<>();
        resultViewers.forEach((viewer) -> {
            viewers.add(viewer);
        });
        return viewers;
    }

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

    public void open() {
        if (null == explorerManager) {
            /*
             * Get an explorer manager to pass to the child result viewers. If
             * the application components are put together as expected, this
             * will be an explorer manager owned by a parent top component, and
             * placed by the top component in the look up that is proxied as the
             * action global context when the top component has focus. The
             * sharing of this explorer manager enables the same child node
             * selections to be made in all of the result viewers.
             */
            explorerManager = ExplorerManager.find(this);
            emNodeSelectionListener = new ExplorerManagerNodeSelectionListener();
            explorerManager.addPropertyChangeListener(emNodeSelectionListener);
        }

        /*
         * Load the child result viewers into the tabbed pane.
         */
        if (0 == dataResultTabbedPanel.getTabCount()) {
            /*
             * TODO (JIRA-2658): Fix the DataResultViewer extension point. When
             * this is done, restore the implementation of DataResultViewerTable
             * and DataREsultViewerThumbnail as DataResultViewer service
             * providers.
             */
            addResultViewer(new DataResultViewerTable(this.explorerManager));
            addResultViewer(new DataResultViewerThumbnail(this.explorerManager));
            for (DataResultViewer factory : Lookup.getDefault().lookupAll(DataResultViewer.class)) {
                DataResultViewer resultViewer;
                if (isMain) {
                    resultViewer = factory;
                } else {
                    resultViewer = factory.createInstance();
                }
                addResultViewer(resultViewer);
            }
        }

        if (isMain && null == rootNode) {
            setNode(rootNode);
        }

        this.setVisible(true);
    }

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

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

        this.rootNode = rootNode;
        if (this.rootNode != null) {
            rootNodeListener.reset();
            this.rootNode.addNodeListener(rootNodeListener);
        }

        resetTabs(this.rootNode);
        setupTabs(this.rootNode);

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

    public Node getRootNode() {
        return rootNode;
    }

    public void setNumMatches(Integer numberOfChildNodes) {
        if (this.numberMatchLabel != null) {
            this.numberMatchLabel.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 < dataResultTabbedPanel.getTabCount(); i++) {
            if (resultViewers.get(i).isSupported(selectedNode)) {
                dataResultTabbedPanel.setEnabledAt(i, true);
            } else {
                dataResultTabbedPanel.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 && dataResultTabbedPanel.isEnabledAt(i)) {
                        tabToSelect = i;
                    }
                }
            }
        };
        if (NO_TAB_SELECTED == tabToSelect) {
            tabToSelect = dataResultTabbedPanel.getSelectedIndex();
            if ((NO_TAB_SELECTED == tabToSelect) || (!dataResultTabbedPanel.isEnabledAt(tabToSelect))) {
                for (int i = 0; i < dataResultTabbedPanel.getTabCount(); ++i) {
                    if (dataResultTabbedPanel.isEnabledAt(i)) {
                        tabToSelect = i;
                        break;
                    }
                }
            }
        }

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

    public void resetTabs(Node unusedSelectedNode) {
        this.resultViewers.forEach((viewer) -> {
            viewer.resetComponent();
        });
    }

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

    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.
         */
        return (!this.isMain) || !Case.isCaseOpen() || Case.getCurrentCase().hasData() == false;
    }

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

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

        if (!this.isMain) {
            this.resultViewers.forEach((viewer) -> {
                viewer.clearComponent();
            });
            this.directoryTablePath.removeAll();
            this.directoryTablePath = null;
            this.numberMatchLabel.removeAll();
            this.numberMatchLabel = null;
            this.matchLabel.removeAll();
            this.matchLabel = null;
            this.setLayout(null);
            this.removeAll();
            this.setVisible(false);
        }
    }

    private class ExplorerManagerNodeSelectionListener implements PropertyChangeListener {

        @Override
        public void propertyChange(PropertyChangeEvent evt) {
            try {
                Case.getCurrentCase();
            } catch (IllegalStateException ex) {
                return;
            }

            /*
             * Only interested in node selection events.
             */
            if (evt.getPropertyName().equals(ExplorerManager.PROP_SELECTED_NODES)) {
                setCursor(Cursor.getPredefinedCursor(Cursor.WAIT_CURSOR));
                try {
                    if (contentView != null) {
                        Node[] selectedNodes = explorerManager.getSelectedNodes();

                        /*
                         * Pass the selected nodes to all of the result viewers
                         * sharing this explorer manager.
                         */
                        resultViewers.forEach((viewer) -> {
                            viewer.setSelectedNodes(selectedNodes);
                        });

                        /*
                         * Passing null signals that either multiple nodes are
                         * selected, or no nodes are selected. This is important
                         * to the content view, since content views only work
                         * for a single node..
                         */
                        if (1 == selectedNodes.length) {
                            contentView.setNode(selectedNodes[0]);
                        } else {
                            contentView.setNode(null);
                        }
                    }
                } finally {
                    setCursor(null);
                }
            }
        }
    }

    private class RootNodeListener implements NodeListener {

        private volatile boolean waitingForData = true;

        public void reset() {
            waitingForData = true;
        }

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

            /*
             * There is a known issue in this code whereby we will only call
             * setupTabs() once even though childrenAdded could be called
             * multiple times. That means that each panel may not have access to
             * all of the children when they decide if they support the content
             */
            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 (rootNode != null && rootNode.getChildren() != null) {
                setNumMatches(rootNode.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() {

        directoryTablePath = new javax.swing.JLabel();
        numberMatchLabel = new javax.swing.JLabel();
        matchLabel = new javax.swing.JLabel();
        dataResultTabbedPanel = new javax.swing.JTabbedPane();

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

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

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

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

        dataResultTabbedPanel.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(directoryTablePath, 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(numberMatchLabel)
                .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
                .addComponent(matchLabel))
            .addComponent(dataResultTabbedPanel, 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(numberMatchLabel)
                        .addComponent(matchLabel))
                    .addComponent(directoryTablePath, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE))
                .addGap(0, 0, 0)
                .addComponent(dataResultTabbedPanel, 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.JTabbedPane dataResultTabbedPanel;
    private javax.swing.JLabel directoryTablePath;
    private javax.swing.JLabel matchLabel;
    private javax.swing.JLabel numberMatchLabel;
    // End of variables declaration//GEN-END:variables

}