AbstractFiltersPanel.java

Go to the documentation of this file.

/*
 * Autopsy
 *
 * Copyright 2020 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.discovery.ui;

import org.sleuthkit.autopsy.discovery.search.AbstractFilter;
import java.awt.Component;
import java.awt.GridBagConstraints;
import java.awt.GridBagLayout;
import java.awt.Insets;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.ArrayList;
import java.util.List;
import javax.swing.JPanel;
import javax.swing.JSplitPane;
import javax.swing.event.ListSelectionEvent;
import javax.swing.event.ListSelectionListener;
import org.apache.commons.lang3.StringUtils;
import org.sleuthkit.autopsy.discovery.search.DiscoveryAttributes.GroupingAttributeType;
import org.sleuthkit.autopsy.discovery.search.Group;
import org.sleuthkit.autopsy.discovery.search.ResultsSorter.SortingMethod;
import org.sleuthkit.autopsy.discovery.search.SearchData;
import org.sleuthkit.autopsy.discovery.search.SearchFiltering;

abstract class AbstractFiltersPanel extends JPanel implements ActionListener, ListSelectionListener {

    private boolean isInitialized = false;
    private static final double LABEL_WEIGHT = 0;
    private static final double PANEL_WEIGHT = .1;
    private static final int LABEL_WIDTH = 1;
    private static final int PANEL_WIDTH = 2;
    private static final int LABEL_HEIGHT = 1;
    private static final int PANEL_HEIGHT = 2;
    private static final long serialVersionUID = 1L;
    private final GridBagConstraints constraints = new GridBagConstraints();
    private final List<AbstractDiscoveryFilterPanel> filters = new ArrayList<>();
    private final JPanel firstColumnPanel = new JPanel();
    private final JPanel secondColumnPanel = new JPanel();
    private int firstColumnY = 0;
    private int secondColumnY = 0;
    private SortingMethod lastSortingMethod = SortingMethod.BY_FILE_NAME;
    private GroupingAttributeType lastGroupingAttributeType = GroupingAttributeType.PARENT_PATH;
    private Group.GroupSortingAlgorithm lastGroupSortingAlg = Group.GroupSortingAlgorithm.BY_GROUP_SIZE;

    AbstractFiltersPanel() {
        firstColumnPanel.setLayout(new GridBagLayout());
        secondColumnPanel.setLayout(new GridBagLayout());
    }

    abstract SearchData.Type getType();

    final synchronized void addFilter(AbstractDiscoveryFilterPanel filterPanel, boolean isSelected, int[] indicesSelected, int column) {
        if (!isInitialized) {
            constraints.gridy = 0;
            constraints.anchor = GridBagConstraints.FIRST_LINE_START;
            constraints.insets = new Insets(8, 8, 8, 8);
            isInitialized = true;
        }
        if (column == 0) {
            constraints.gridy = firstColumnY;
        } else {
            constraints.gridy = secondColumnY;
        }
        constraints.gridx = 0;
        filterPanel.configurePanel(isSelected, indicesSelected);
        filterPanel.addListeners(this, this);
        filters.add(filterPanel);
        constraints.fill = GridBagConstraints.VERTICAL;
        constraints.gridheight = LABEL_HEIGHT;
        constraints.gridwidth = LABEL_WIDTH;
        constraints.weightx = LABEL_WEIGHT;
        constraints.weighty = LABEL_WEIGHT;
        constraints.gridwidth = LABEL_WIDTH;
        addToGridBagLayout(filterPanel.getCheckbox(), filterPanel.getAdditionalLabel(), column);
        if (filterPanel.hasPanel()) {
            constraints.gridx += constraints.gridwidth;
            constraints.fill = GridBagConstraints.BOTH;
            constraints.gridheight = PANEL_HEIGHT;
            constraints.weightx = PANEL_WEIGHT;
            constraints.weighty = PANEL_WEIGHT;
            constraints.gridwidth = PANEL_WIDTH;
            addToGridBagLayout(filterPanel, null, column);
        }
        if (column == 0) {
            firstColumnY += constraints.gridheight;
        } else {
            secondColumnY += constraints.gridheight;
        }
    }

    final void addPanelsToScrollPane(JSplitPane splitPane) {
        splitPane.setLeftComponent(firstColumnPanel);
        splitPane.setRightComponent(secondColumnPanel);
        validate();
        repaint();
    }

    final synchronized void clearFilters() {
        for (AbstractDiscoveryFilterPanel filterPanel : filters) {
            filterPanel.removeListeners();
        }
        filters.clear();
    }

    private void addToGridBagLayout(Component componentToAdd, Component additionalComponentToAdd, int columnIndex) {
        addToColumn(componentToAdd, columnIndex);
        if (additionalComponentToAdd != null) {
            constraints.gridy += constraints.gridheight;
            addToColumn(additionalComponentToAdd, columnIndex);
            constraints.gridy -= constraints.gridheight;
        }
    }

    private void addToColumn(Component component, int columnNumber) {
        if (columnNumber == 0) {
            firstColumnPanel.add(component, constraints);
        } else {
            secondColumnPanel.add(component, constraints);
        }
    }

    synchronized void validateFields() {
        String errorString = null;
        for (AbstractDiscoveryFilterPanel filterPanel : filters) {
            errorString = filterPanel.checkForError();
            if (!StringUtils.isBlank(errorString)) {
                break;
            }
        }
        firePropertyChange("FilterError", null, errorString);
    }

    @Override
    public void actionPerformed(ActionEvent e) {
        validateFields();
        validate();
        repaint();
    }

    boolean isObjectsFilterSupported() {
        for (AbstractDiscoveryFilterPanel filter : filters) {
            if (filter instanceof ObjectDetectedFilterPanel) {
                return filter.getList().getModel().getSize() > 0;
            }
        }
        return false;
    }

    boolean isHashSetFilterSupported() {
        for (AbstractDiscoveryFilterPanel filter : filters) {
            if (filter instanceof HashSetFilterPanel) {
                return filter.getList().getModel().getSize() > 0;
            }
        }
        return false;
    }

    boolean isInterestingItemsFilterSupported() {
        for (AbstractDiscoveryFilterPanel filter : filters) {
            if (filter instanceof InterestingItemsFilterPanel) {
                return filter.getList().getModel().getSize() > 0;
            }
        }
        return false;
    }

    synchronized List<AbstractFilter> getFilters() {

        List<AbstractFilter> filtersToUse = new ArrayList<>();
        if (getType() != SearchData.Type.DOMAIN) { //Domain type does not have a file type
            filtersToUse.add(new SearchFiltering.FileTypeFilter(getType()));
        }
        for (AbstractDiscoveryFilterPanel filterPanel : filters) {
            if (filterPanel.getCheckbox().isSelected()) {
                AbstractFilter filter = filterPanel.getFilter();
                if (filter != null) {
                    filtersToUse.add(filter);
                }
            }
        }
        return filtersToUse;
    }

    @Override
    public void valueChanged(ListSelectionEvent evt) {
        if (!evt.getValueIsAdjusting()) {
            validateFields();
            validate();
            repaint();
        }
    }

    SortingMethod getLastSortingMethod() {
        return lastSortingMethod;
    }

    final void setLastSortingMethod(SortingMethod lastSortingMethod) {
        this.lastSortingMethod = lastSortingMethod;
    }

    GroupingAttributeType getLastGroupingAttributeType() {
        return lastGroupingAttributeType;
    }

    final void setLastGroupingAttributeType(GroupingAttributeType lastGroupingAttributeType) {
        this.lastGroupingAttributeType = lastGroupingAttributeType;
    }

    Group.GroupSortingAlgorithm getLastGroupSortingAlg() {
        return lastGroupSortingAlg;
    }

    final void setLastGroupSortingAlg(Group.GroupSortingAlgorithm lastGroupSortingAlg) {
        this.lastGroupSortingAlg = lastGroupSortingAlg;
    }

}