JTablePanel.java

Go to the documentation of this file.

/*
 * Autopsy Forensic Browser
 *
 * 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.datasourcesummary.uiutils;

import java.awt.BorderLayout;
import java.awt.Graphics;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.util.Collections;
import java.util.List;
import java.util.function.Function;
import java.util.stream.Collectors;
import javax.swing.JComponent;
import javax.swing.JLayer;
import javax.swing.JScrollPane;
import javax.swing.JTable;
import javax.swing.plaf.LayerUI;
import javax.swing.table.DefaultTableColumnModel;
import javax.swing.table.TableColumn;
import javax.swing.table.TableColumnModel;
import org.sleuthkit.autopsy.datasourcesummary.uiutils.CellModelTableCellRenderer.CellModel;

public class JTablePanel<T> extends AbstractLoadableComponent<List<T>> {

    public static class CellMouseEvent {

        private final MouseEvent e;
        private final JTable table;
        private final int row;
        private final int col;
        private final Object cellValue;

        public CellMouseEvent(MouseEvent e, JTable table, int row, int col, Object cellValue) {
            this.e = e;
            this.table = table;
            this.row = row;
            this.col = col;
            this.cellValue = cellValue;
        }

        public MouseEvent getMouseEvent() {
            return e;
        }

        public JTable getTable() {
            return table;
        }

        public int getRow() {
            return row;
        }

        public int getCol() {
            return col;
        }

        public Object getCellValue() {
            return cellValue;
        }
    }

    public interface CellMouseListener {

        void mouseClicked(CellMouseEvent e);
    }

    private static class Overlay extends LayerUI<JComponent> {

        private static final long serialVersionUID = 1L;
        private final BaseMessageOverlay overlayDelegate = new BaseMessageOverlay();

        void setVisible(boolean visible) {
            overlayDelegate.setVisible(visible);
        }

        void setMessage(String message) {
            overlayDelegate.setMessage(message);
        }

        @Override
        public void paint(Graphics g, JComponent c) {
            super.paint(g, c);
            overlayDelegate.paintOverlay(g, c.getWidth(), c.getHeight());
        }
    }

    public static class ColumnModel<T> {

        private final String headerTitle;
        private final Function<T, CellModelTableCellRenderer.CellModel> cellRenderer;
        private final Integer width;

        public ColumnModel(String headerTitle, Function<T, CellModelTableCellRenderer.CellModel> cellRenderer) {
            this(headerTitle, cellRenderer, null);
        }

        public ColumnModel(String headerTitle, Function<T, CellModelTableCellRenderer.CellModel> cellRenderer, Integer width) {
            this.headerTitle = headerTitle;
            this.cellRenderer = cellRenderer;
            this.width = width;
        }

        public String getHeaderTitle() {
            return headerTitle;
        }

        public Function<T, CellModel> getCellRenderer() {
            return cellRenderer;
        }

        public Integer getWidth() {
            return width;
        }
    }

    private static final long serialVersionUID = 1L;

    private static final CellModelTableCellRenderer DEFAULT_CELL_RENDERER = new CellModelTableCellRenderer();

    public static <T> TableColumnModel getTableColumnModel(List<ColumnModel<T>> columns) {
        TableColumnModel tableModel = new DefaultTableColumnModel();

        for (int i = 0; i < columns.size(); i++) {
            TableColumn col = new TableColumn(i);
            ColumnModel<T> model = columns.get(i);
            // if a preferred width is specified in the column definition, 
            // set the underlying TableColumn preferred width.
            if (model.getWidth() != null && model.getWidth() >= 0) {
                col.setPreferredWidth(model.getWidth());
            }

            // set the title
            col.setHeaderValue(model.getHeaderTitle());

            // use the cell model renderer in this instance
            col.setCellRenderer(DEFAULT_CELL_RENDERER);

            tableModel.addColumn(col);
        }

        return tableModel;
    }

    public static <T> ListTableModel<T> getTableModel(List<ColumnModel<T>> columns) {
        List<Function<T, ? extends Object>> columnRenderers = columns.stream()
                .map((colModel) -> colModel.getCellRenderer())
                .collect(Collectors.toList());

        return new DefaultListTableModel<T>(columnRenderers);
    }

    public static <T> JTablePanel<T> getJTablePanel(List<ColumnModel<T>> columns) {
        ListTableModel<T> tableModel = getTableModel(columns);
        JTablePanel<T> resultTable = new JTablePanel<>(tableModel)
                .setColumnModel(getTableColumnModel(columns))
                .setCellListener(CellModelTableCellRenderer.getMouseListener());

        return resultTable;
    }

    private JScrollPane tableScrollPane;
    private Overlay overlayLayer;
    private ListTableModel<T> tableModel;
    private JTable table;
    private CellMouseListener cellListener = null;
    private Function<T, ? extends Object> keyFunction = (rowItem) -> rowItem;

    public JTablePanel(ListTableModel<T> tableModel) {
        this();
        setModel(tableModel);
    }

    public JTablePanel() {
        initComponents();
        this.table.addMouseListener(new MouseAdapter() {

            @Override
            public void mouseClicked(MouseEvent e) {
                // make sure click event isn't primary button and table is present
                if (cellListener != null) {
                    int row = table.rowAtPoint(e.getPoint());
                    int col = table.columnAtPoint(e.getPoint());

                    // make sure there is a value at the row,col of click event.
                    if (tableModel != null
                            && row >= 0 && row < tableModel.getRowCount()
                            && col >= 0 && col < tableModel.getColumnCount()) {

                        Object cellValue = tableModel.getValueAt(row, col);
                        cellListener.mouseClicked(new CellMouseEvent(e, table, row, col, cellValue));
                    }
                }
            }
        });
    }

    public final JTablePanel<T> setModel(ListTableModel<T> tableModel) {
        if (tableModel == null) {
            throw new IllegalArgumentException("Null table model passed to setModel");
        }

        this.tableModel = tableModel;
        table.setModel(tableModel);
        return this;
    }

    public CellMouseListener getCellListener() {
        return cellListener;
    }

    public JTablePanel<T> setCellListener(CellMouseListener cellListener) {
        this.cellListener = cellListener;
        return this;
    }

    public TableColumnModel getColumnModel() {
        return this.table.getColumnModel();
    }

    public JTablePanel<T> setColumnModel(TableColumnModel columnModel) {
        this.table.setColumnModel(columnModel);
        return this;
    }

    public Function<T, ? extends Object> getKeyFunction() {
        return keyFunction;
    }

    public JTablePanel<T> setKeyFunction(Function<T, ? extends Object> keyFunction) {
        if (keyFunction == null) {
            throw new IllegalArgumentException("Key function must be non-null");
        }

        this.keyFunction = keyFunction;
        return this;
    }

    @Override
    protected synchronized void setResults(List<T> data) {
        // get previously selected value
        int prevSelectedRow = this.table.getSelectedRow();
        List<T> tableRows = this.tableModel.getDataRows();
        T prevValue = (tableRows != null && prevSelectedRow >= 0 && prevSelectedRow < tableRows.size())
                ? this.tableModel.getDataRows().get(prevSelectedRow)
                : null;

        Object prevKeyValue = (prevValue == null) ? null : this.keyFunction.apply(prevValue);

        // set the list of data to be shown as either the data or an empty list 
        // on null.
        List<T> dataToSet = (data == null) ? Collections.emptyList() : data;

        // set the underlying table model's data.
        this.tableModel.setDataRows(dataToSet);

        // set the row to selected value if the value is found
        if (prevKeyValue != null) {
            for (int objIndex = 0; objIndex < dataToSet.size(); objIndex++) {
                Object thisKey = this.keyFunction.apply(dataToSet.get(objIndex));
                if (prevKeyValue.equals(thisKey)) {
                    this.table.setRowSelectionInterval(objIndex, objIndex);
                    break;
                }
            }
        }

    }

    @Override
    protected void setMessage(boolean visible, String message) {
        this.overlayLayer.setVisible(visible);
        this.overlayLayer.setMessage(message);
    }

    private void initComponents() {
        table = new JTable();
        table.getTableHeader().setReorderingAllowed(false);
        overlayLayer = new Overlay();
        tableScrollPane = new JScrollPane(table);
        JLayer<JComponent> dualLayer = new JLayer<>(tableScrollPane, overlayLayer);
        setLayout(new BorderLayout());
        add(dualLayer, BorderLayout.CENTER);
    }
}