Dépôt officiel du code source de l'ERP OpenConcerto

/*

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.

 *

 * Copyright 2011-2019 OpenConcerto, by ILM Informatique. All rights reserved.

 *

 * The contents of this file are subject to the terms of the GNU General Public License Version 3

 * only ("GPL"). You may not use this file except in compliance with the License. You can obtain a

 * copy of the License at http://www.gnu.org/licenses/gpl-3.0.html See the License for the specific

 * language governing permissions and limitations under the License.

 *

 * When distributing the software, include this License Header Notice in each file.

 */

 package org.openconcerto.utils;

/*

 * Créé le 21 févr. 2005

 */

import java.awt.Color;

import java.awt.Component;

import java.awt.Graphics;

import java.awt.event.MouseAdapter;

import java.awt.event.MouseEvent;

import java.awt.event.MouseListener;

import java.beans.PropertyChangeListener;

import java.beans.PropertyChangeSupport;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Collections;

import java.util.Comparator;

import java.util.HashMap;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import javax.swing.Icon;

import javax.swing.JLabel;

import javax.swing.JTable;

import javax.swing.SwingConstants;

import javax.swing.SwingUtilities;

import javax.swing.event.TableModelEvent;

import javax.swing.event.TableModelListener;

import javax.swing.table.AbstractTableModel;

import javax.swing.table.JTableHeader;

import javax.swing.table.TableCellRenderer;

import javax.swing.table.TableColumnModel;

import javax.swing.table.TableModel;

import net.jcip.annotations.Immutable;

/**

 * TableSorter is a decorator for TableModels; adding sorting functionality to a supplied

 * TableModel. TableSorter does not store or copy the data in its TableModel; instead it maintains a

 * map from the row indexes of the view to the row indexes of the model. As requests are made of the

 * sorter (like getValueAt(row, col)) they are passed to the underlying model after the row numbers

 * have been translated via the internal mapping array. This way, the TableSorter appears to hold

 * another copy of the table with the rows in a different order.

 * <p/>

 * TableSorter registers itself as a listener to the underlying model, just as the JTable itself

 * would. Events recieved from the model are examined, sometimes manipulated (typically widened),

 * and then passed on to the TableSorter's listeners (typically the JTable). If a change to the

 * model has invalidated the order of TableSorter's rows, a note of this is made and the sorter will

 * resort the rows the next time a value is requested.

 * <p/>

 * When the tableHeader property is set, either by using the setTableHeader() method or the two

 * argument constructor, the table header may be used as a complete UI for TableSorter. The default

 * renderer of the tableHeader is decorated with a renderer that indicates the sorting status of

 * each column. In addition, a mouse listener is installed with the following behavior:

 * <ul>

 * <li>Mouse-click: Clears the sorting status of all other columns and advances the sorting status

 * of that column through three values: {NOT_SORTED, ASCENDING, DESCENDING} (then back to NOT_SORTED

 * again).

 * <li>SHIFT-mouse-click: Clears the sorting status of all other columns and cycles the sorting

 * status of the column through the same three values, in the opposite order: {NOT_SORTED,

 * DESCENDING, ASCENDING}.

 * <li>CONTROL-mouse-click and CONTROL-SHIFT-mouse-click: as above except that the changes to the

 * column do not cancel the statuses of columns that are already sorting - giving a way to initiate

 * a compound sort.

 * </ul>

 * <p/>

 * This is a long overdue rewrite of a class of the same name that first appeared in the swing table

 * demos in 1997.

 *

 * @author Philip Milne

 * @author Brendon McLean

 * @author Dan van Enckevort

 * @author Parwinder Sekhon

 * @version 2.0 02/27/04

 */

@SuppressWarnings("unqualified-field-access")

public class TableSorter extends AbstractTableModel {

    protected TableModel tableModel;

    public static final int DESCENDING = -1;

    public static final int NOT_SORTED = 0;

    public static final int ASCENDING = 1;

    private static Directive EMPTY_DIRECTIVE = new Directive(-1, NOT_SORTED);

    public static final Comparator COMPARABLE_COMAPRATOR = new Comparator() {

        @Override

        public int compare(Object o1, Object o2) {

            return ((Comparable) o1).compareTo(o2);

        }

    };

    public static final Comparator<Object> LEXICAL_COMPARATOR = new Comparator<Object>() {

        @Override

        public int compare(Object o1, Object o2) {

            return o1.toString().compareTo(o2.toString());

        }

    };

    private Row[] viewToModel;

    private int[] modelToView;

    private JTableHeader tableHeader;

    private MouseListener mouseListener;

    private TableModelListener tableModelListener;

    private Map<Class<?>, Comparator<?>> columnComparators = new HashMap<>();

    private final List<Directive> sortingColumns = new ArrayList<>();

    private boolean enabled;

    private boolean sorting;

    private final PropertyChangeSupport supp;

    public TableSorter() {

        this.mouseListener = new MouseHandler();

        this.tableModelListener = new TableModelHandler();

        this.enabled = true;

        this.sorting = false;

        this.supp = new PropertyChangeSupport(this);

    }

    public TableSorter(TableModel tableModel) {

        this();

        setTableModel(tableModel);

    }

    public TableSorter(TableModel tableModel, JTableHeader tableHeader) {

        this();

        setTableHeader(tableHeader);

        setTableModel(tableModel);

    }

    private void clearSortingState() {

        viewToModel = null;

        modelToView = null;

    }

    public TableModel getTableModel() {

        return tableModel;

    }

    public void setTableModel(TableModel tableModel) {

        if (!SwingUtilities.isEventDispatchThread()) {

            throw new IllegalStateException("must be called from EDT");

        }

        if (this.tableModel != null) {

            this.tableModel.removeTableModelListener(tableModelListener);

        }

        final TableModel old = this.tableModel;

        this.tableModel = tableModel;

        this.supp.firePropertyChange("tableModel", old, tableModel);

        if (this.tableModel != null) {

            this.tableModel.addTableModelListener(tableModelListener);

        }

        clearSortingState();

        if (this.tableModel != null)

            fireTableStructureChanged();

    }

    public final void setSortingEnabled(final boolean b) {

        this.setSortingEnabled(b, true);

    }

    // this prevent the user from changing the sort, but setSortingStatus() still works (like

    // JTextComponent.setEnabled()/setText())

    public final void setSortingEnabled(final boolean b, final boolean cancelSort) {

        if (this.enabled != b) {

            this.enabled = b;

            if (this.enabled) {

                this.tableHeader.addMouseListener(mouseListener);

            } else {

                this.tableHeader.removeMouseListener(mouseListener);

            }

            if (cancelSort && this.isSorting())

                this.cancelSorting(true);

        }

    }

    public final boolean isSortingEnabled() {

        return this.enabled;

    }

    public JTableHeader getTableHeader() {

        return tableHeader;

    }

    public void setTableHeader(JTableHeader tableHeader) {

        if (!SwingUtilities.isEventDispatchThread()) {

            throw new IllegalStateException("must be called from EDT");

        }

        if (this.tableHeader != null) {

            this.tableHeader.removeMouseListener(mouseListener);

            TableCellRenderer defaultRenderer = this.tableHeader.getDefaultRenderer();

            if (defaultRenderer instanceof SortableHeaderRenderer) {

                this.tableHeader.setDefaultRenderer(((SortableHeaderRenderer) defaultRenderer).tableCellRenderer);

            }

        }

        this.tableHeader = tableHeader;

        if (this.tableHeader != null) {

            if (this.isSortingEnabled())

                this.tableHeader.addMouseListener(mouseListener);

            this.tableHeader.setDefaultRenderer(new SortableHeaderRenderer(this.tableHeader.getDefaultRenderer()));

        }

    }

    public boolean isSorting() {

        return sortingColumns.size() != 0;

    }

    public final List<Directive> getSortingColumns() {

        return Collections.unmodifiableList(this.sortingColumns);

    }

    public void setSortingColumns(List<Directive> sortingColumns) {

        if (!SwingUtilities.isEventDispatchThread()) {

            throw new IllegalStateException("must be called from EDT");

        }

        this.sortingColumns.clear();

        this.sortingColumns.addAll(sortingColumns);

        sortingStatusChanged();

    }

    private Directive getDirective(int column) {

        for (int i = 0; i < sortingColumns.size(); i++) {

            Directive directive = sortingColumns.get(i);

            if (directive.column == column) {

                return directive;

            }

        }

        return EMPTY_DIRECTIVE;

    }

    public int getSortingStatus(int column) {

        return getDirective(column).direction;

    }

    public synchronized boolean isBeingSorted() {

        return this.sorting;

    }

    private void setSorting(boolean sorting) {

        final boolean old = this.sorting;

        if (old != sorting) {

            this.sorting = sorting;

            this.supp.firePropertyChange("sorting", old, this.sorting);

        }

    }

    private synchronized void sortingStatusChanged() {

        if (!SwingUtilities.isEventDispatchThread()) {

            throw new IllegalStateException("must be called from EDT");

        }

        this.sortingStatusChanged(true);

    }

    private synchronized void sortingStatusChanged(final boolean fire) {

        clearSortingState();

        if (fire) {

            fireTableDataChanged();

        }

        if (tableHeader != null) {

            tableHeader.repaint();

        }

    }

    public void setSortingStatus(int column, int status) {

        Directive directive = getDirective(column);

        if (directive != EMPTY_DIRECTIVE) {

            sortingColumns.remove(directive);

        }

        if (status != NOT_SORTED) {

            sortingColumns.add(new Directive(column, status));

        }

        sortingStatusChanged();

    }

    protected Icon getHeaderRendererIcon(int column, int size) {

        Directive directive = getDirective(column);

        if (directive == EMPTY_DIRECTIVE) {

            return null;

        }

        return new Arrow(directive.direction == DESCENDING, size, sortingColumns.indexOf(directive));

    }

    private void cancelSorting(final boolean fire) {

        sortingColumns.clear();

        sortingStatusChanged(fire);

    }

    public void setColumnComparator(Class<?> type, Comparator<?> comparator) {

        if (comparator == null) {

            columnComparators.remove(type);

        } else {

            columnComparators.put(type, comparator);

        }

    }

    protected Comparator getComparator(int column) {

        Class<?> columnType = tableModel.getColumnClass(column);

        Comparator<?> comparator = columnComparators.get(columnType);

        if (comparator != null) {

            return comparator;

        }

        if (Comparable.class.isAssignableFrom(columnType)) {

            return COMPARABLE_COMAPRATOR;

        }

        return LEXICAL_COMPARATOR;

    }

    private Row[] getViewToModel() {

        if (!SwingUtilities.isEventDispatchThread()) {

            throw new IllegalStateException("must be called from EDT");

        }

        if (viewToModel == null) {

            int tableModelRowCount = tableModel.getRowCount();

            viewToModel = new Row[tableModelRowCount];

            for (int row = 0; row < tableModelRowCount; row++) {

                viewToModel[row] = new Row(row);

            }

            if (isSorting()) {

                Arrays.sort(viewToModel);

            }

        }

        return viewToModel;

    }

    /**

     * Returns the model index for the passed view index. Eg if the 5th row in the model is sorted

     * at the first position, modelIndex(1) will return 5.

     *

     * @param viewIndex the index in the view (eg a JTable).

     * @return the corresponding index in the model.

     */

    public int modelIndex(int viewIndex) {

        try {

            return getViewToModel()[viewIndex].modelIndex;

        } catch (Exception e) {

            throw new IllegalStateException(this + " couldn't get model index for view index " + viewIndex + " with " + this.getTableModel().getRowCount() + " row(s) in our model", e);

        }

    }

    private int[] getModelToView() {

        if (!SwingUtilities.isEventDispatchThread()) {

            throw new IllegalStateException("must be called from EDT");

        }

        if (modelToView == null) {

            int n = getViewToModel().length;

            modelToView = new int[n];

            for (int i = 0; i < n; i++) {

                modelToView[modelIndex(i)] = i;

            }

        }

        return modelToView;

    }

    public int viewIndex(int modelIndex) {

        return getModelToView()[modelIndex];

    }

    // TableModel interface methods

    @Override

    public int getRowCount() {

        if (!SwingUtilities.isEventDispatchThread()) {

            throw new IllegalStateException("must be called from EDT");

        }

        return (tableModel == null) ? 0 : tableModel.getRowCount();

    }

    @Override

    public int getColumnCount() {

        if (!SwingUtilities.isEventDispatchThread()) {

            throw new IllegalStateException("must be called from EDT");

        }

        return (tableModel == null) ? 0 : tableModel.getColumnCount();

    }

    @Override

    public String getColumnName(int column) {

        return tableModel.getColumnName(column);

    }

    @Override

    public Class<?> getColumnClass(int column) {

        return tableModel.getColumnClass(column);

    }

    @Override

    public boolean isCellEditable(int row, int column) {

        return tableModel.isCellEditable(modelIndex(row), column);

    }

    @Override

    public Object getValueAt(int row, int column) {

        if (!SwingUtilities.isEventDispatchThread()) {

            throw new IllegalStateException("must be called from EDT");

        }

        return tableModel.getValueAt(modelIndex(row), column);

    }

    @Override

    public void setValueAt(Object aValue, int row, int column) {

        if (!SwingUtilities.isEventDispatchThread()) {

            throw new IllegalStateException("must be called from EDT");

        }

        tableModel.setValueAt(aValue, modelIndex(row), column);

    }

    public void addPropertyChangeListener(PropertyChangeListener l) {

        this.supp.addPropertyChangeListener(l);

    }

    public void addPropertyChangeListener(String name, PropertyChangeListener l) {

        this.supp.addPropertyChangeListener(name, l);

    }

    public void rmPropertyChangeListener(PropertyChangeListener l) {

        this.supp.removePropertyChangeListener(l);

    }

    @Override

    public String toString() {

        return this.getClass().getSimpleName() + " on " + this.getTableModel();

    }

    // Helper classes

    private class Row implements Comparable<Row> {

        private int modelIndex;

        public Row(int index) {

            this.modelIndex = index;

        }

        @Override

        public int compareTo(Row o) {

            int row1 = modelIndex;

            int row2 = o.modelIndex;

            for (Iterator<Directive> it = sortingColumns.iterator(); it.hasNext();) {

                Directive directive = it.next();

                int column = directive.column;

                Object o1 = tableModel.getValueAt(row1, column);

                Object o2 = tableModel.getValueAt(row2, column);

                int comparison = 0;

                // Define null less than everything, except null.

                if (o1 == null && o2 == null) {

                    comparison = 0;

                } else if (o1 == null) {

                    comparison = -1;

                } else if (o2 == null) {

                    comparison = 1;

                } else {

                    final Comparator comparator = getComparator(column);

                    try {

                        comparison = comparator.compare(o1, o2);

                    } catch (Exception e) {

                        throw new IllegalStateException("Couldn't compare column " + column + " using " + comparator + " for objects " + o1 + " and " + o2, e);

                    }

                }

                if (comparison != 0) {

                    return directive.direction == DESCENDING ? -comparison : comparison;

                }

            }

            return 0;

        }

    }

    private class TableModelHandler implements TableModelListener {

        @Override

        public void tableChanged(TableModelEvent e) {

            // If we're not sorting by anything, just pass the event along.

            if (!isSorting()) {

                clearSortingState();

                fireTableChanged(e);

                return;

            }

            // If the table structure has changed, cancel the sorting; the

            // sorting columns may have been either moved or deleted from

            // the model.

            if (e.getFirstRow() == TableModelEvent.HEADER_ROW) {

                // don't fire a tableChanged otherwise listeners could access removed columns

                // (since we're firing a tableChanged before the structureChanged)

                cancelSorting(false);

                fireTableChanged(e);

                return;

            }

            // We can map a cell event through to the view without widening

            // when the following conditions apply:

            //

            // a) all the changes are on one row (e.getFirstRow() == e.getLastRow()) and,

            // b) all the changes are in one column (column != TableModelEvent.ALL_COLUMNS) and,

            // c) we are not sorting on that column (getSortingStatus(column) == NOT_SORTED) and,

            // d) a reverse lookup will not trigger a sort (modelToView != null)

            //

            // Note: INSERT and DELETE events fail this test as they have column == ALL_COLUMNS.

            //

            // The last check, for (modelToView != null) is to see if modelToView

            // is already allocated. If we don't do this check; sorting can become

            // a performance bottleneck for applications where cells

            // change rapidly in different parts of the table. If cells

            // change alternately in the sorting column and then outside of

            // it this class can end up re-sorting on alternate cell updates -

            // which can be a performance problem for large tables. The last

            // clause avoids this problem.

            int column = e.getColumn();

            if (e.getFirstRow() == e.getLastRow() && column != TableModelEvent.ALL_COLUMNS && modelToView != null && doesntChangeSort(e)) {

                int viewIndex = getModelToView()[e.getFirstRow()];

                fireTableChanged(new TableModelEvent(TableSorter.this, viewIndex, viewIndex, column, e.getType()));

                return;

            }

            // Something has happened to the data that may have invalidated the row order.

            clearSortingState();

            fireTableDataChanged();

            return;

        }

    }

    // whether e change the order of the rows

    private boolean doesntChangeSort(TableModelEvent e) {

        int column = e.getColumn();

        if (getSortingStatus(column) == NOT_SORTED)

            return true;

        final int viewIndex = getModelToView()[e.getFirstRow()];

        // the changed row plus the previous and next ones.

        final List<Row> currentL = new ArrayList<Row>();

        if (viewIndex > 0)

            currentL.add(getViewToModel()[viewIndex - 1]);

        currentL.add(getViewToModel()[viewIndex]);

        if (viewIndex < getViewToModel().length - 1)

            currentL.add(getViewToModel()[viewIndex + 1]);

        // the new order

        final List<Row> newL = new ArrayList<Row>(currentL);

        Collections.sort(newL);

        return currentL.equals(newL);

    }

    private class MouseHandler extends MouseAdapter {

        @Override

        public void mouseClicked(MouseEvent e) {

            JTableHeader h = (JTableHeader) e.getSource();

            TableColumnModel columnModel = h.getColumnModel();

            int viewColumn = columnModel.getColumnIndexAtX(e.getX());

            // don't continue if we can't find the column

            if (viewColumn == -1)

                return;

            int column = columnModel.getColumn(viewColumn).getModelIndex();

            if (column != -1) {

                setSorting(true);

                int status = getSortingStatus(column);

                if (!e.isControlDown()) {

                    // don't need to fire since setSortingStatus() will

                    cancelSorting(false);

                }

                // Cycle the sorting states through {NOT_SORTED, ASCENDING, DESCENDING} or

                // {NOT_SORTED, DESCENDING, ASCENDING} depending on whether shift is pressed.

                status = status + (e.isShiftDown() ? -1 : 1);

                status = (status + 4) % 3 - 1; // signed mod, returning {-1, 0, 1}

                setSortingStatus(column, status);

                setSorting(false);

            }

        }

    }

    private static class Arrow implements Icon {

        private boolean descending;

        private int size;

        private int priority;

        public Arrow(boolean descending, int size, int priority) {

            this.descending = descending;

            this.size = size;

            this.priority = priority;

        }

        @Override

        public void paintIcon(Component c, Graphics g, int x, int y) {

            Color color = c == null ? Color.GRAY : c.getBackground();

            // In a compound sort, make each succesive triangle 20%

            // smaller than the previous one.

            int dx = (int) (size / 2 * Math.pow(0.8, priority));

            int dy = descending ? dx : -dx;

            // Align icon (roughly) with font baseline.

            y = y + 5 * size / 6 + (descending ? -dy : 0);

            int shift = descending ? 1 : -1;

            g.translate(x, y);

            // Right diagonal.

            g.setColor(color.darker());

            g.drawLine(dx / 2, dy, 0, 0);

            g.drawLine(dx / 2, dy + shift, 0, shift);

            // Left diagonal.

            g.setColor(color.brighter());

            g.drawLine(dx / 2, dy, dx, 0);

            g.drawLine(dx / 2, dy + shift, dx, shift);

            // Horizontal line.

            if (descending) {

                g.setColor(color.darker().darker());

            } else {

                g.setColor(color.brighter().brighter());

            }

            g.drawLine(dx, 0, 0, 0);

            g.setColor(color);

            g.translate(-x, -y);

        }

        @Override

        public int getIconWidth() {

            return size;

        }

        @Override

        public int getIconHeight() {

            return size;

        }

    }

    private class SortableHeaderRenderer implements TableCellRenderer {

        private TableCellRenderer tableCellRenderer;

        public SortableHeaderRenderer(TableCellRenderer tableCellRenderer) {

            this.tableCellRenderer = tableCellRenderer;

        }

        @Override

        public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus, int row, int column) {

            if (column < 0) {

                Log.get().severe("out of bound renderer, column :" + column);

                return new JLabel("");

            }

            Component c = tableCellRenderer.getTableCellRendererComponent(table, value, isSelected, hasFocus, row, column);

            if (c instanceof JLabel) {

                JLabel l = (JLabel) c;

                l.setHorizontalTextPosition(SwingConstants.LEFT);

                int modelColumn = table.convertColumnIndexToModel(column);

                l.setIcon(getHeaderRendererIcon(modelColumn, l.getFont().getSize()));

            }

            return c;

        }

    }

    @Immutable

    public static class Directive {

        private final int column;

        private final int direction;

        public Directive(int column, int direction) {

            this.column = column;

            this.direction = direction;

        }

        public final int getColumn() {

            return this.column;

        }

        public final int getDirection() {

            return this.direction;

        }

        @Override

        public String toString() {

            return this.getClass().getSimpleName() + " " + this.getDirection() + " on column " + this.getColumn();

        }

    }

}