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.ui.table;

import java.util.Collections;

import java.util.List;

import java.util.Vector;

import javax.swing.table.DefaultTableColumnModel;

import javax.swing.table.TableColumn;

/**

 * <code>XTableColumnModel</code> extends the DefaultTableColumnModel . It provides a comfortable

 * way to hide/show columns. Columns keep their positions when hidden and shown again.

 *

 * In order to work with JTable it cannot add any events to <code>TableColumnModelListener</code>.

 * Therefore hiding a column will result in <code>columnRemoved</code> event and showing it again

 * will notify listeners of a <code>columnAdded</code>, and possibly a <code>columnMoved</code>

 * event. For the same reason the following methods still deal with visible columns only:

 * getColumnCount(), getColumns(), getColumnIndex(), getColumn() There are overloaded versions of

 * these methods that take a parameter <code>onlyVisible</code> which let's you specify wether you

 * want invisible columns taken into account.

 *

 * @version 0.9 04/03/01

 * @author Stephen Kelvin, mail@StephenKelvin.de

 * @see DefaultTableColumnModel

 */

@SuppressWarnings("unqualified-field-access")

public class XTableColumnModel extends DefaultTableColumnModel {

    /**

     * Array of TableColumn objects in this model. Holds all column objects, regardless of their

     * visibility

     */

    protected List<TableColumn> allTableColumns = new Vector<TableColumn>();

    /**

     * Creates an extended table column model.

     */

    public XTableColumnModel() {

    }

    /**

     * Sets the visibility of the specified TableColumn. The call is ignored if the TableColumn is

     * not found in this column model or its visibility status did not change.

     * <p>

     *

     * @param column the column to show/hide

     * @param visible its new visibility status

     */

    // listeners will receive columnAdded()/columnRemoved() event

    public void setColumnVisible(TableColumn column, boolean visible) {

        if (!visible) {

            super.removeColumn(column);

        } else {

            // find the visible index of the column:

            // iterate through both collections of visible and all columns, counting

            // visible columns up to the one that's about to be shown again

            int noVisibleColumns = tableColumns.size();

            int noInvisibleColumns = allTableColumns.size();

            int visibleIndex = 0;

            for (int invisibleIndex = 0; invisibleIndex < noInvisibleColumns; ++invisibleIndex) {

                TableColumn visibleColumn = (visibleIndex < noVisibleColumns ? (TableColumn) tableColumns.get(visibleIndex) : null);

                TableColumn testColumn = allTableColumns.get(invisibleIndex);

                if (testColumn == column) {

                    if (visibleColumn != column) {

                        super.addColumn(column);

                        super.moveColumn(tableColumns.size() - 1, visibleIndex);

                    }

                    return; // ####################

                }

                if (testColumn == visibleColumn) {

                    ++visibleIndex;

                }

            }

        }

    }

    /**

     * Makes all columns in this model visible

     */

    public void setAllColumnsVisible() {

        int noColumns = allTableColumns.size();

        for (int columnIndex = 0; columnIndex < noColumns; ++columnIndex) {

            TableColumn visibleColumn = (columnIndex < tableColumns.size() ? (TableColumn) tableColumns.get(columnIndex) : null);

            TableColumn invisibleColumn = allTableColumns.get(columnIndex);

            if (visibleColumn != invisibleColumn) {

                super.addColumn(invisibleColumn);

                super.moveColumn(tableColumns.size() - 1, columnIndex);

            }

        }

    }

    /**

     * Maps the index of the column in the table model at <code>modelColumnIndex</code> to the

     * TableColumn object. There may me multiple TableColumn objects showing the same model column,

     * though this is uncommon. This method will always return the first visible or else the first

     * invisible column with the specified index.

     *

     * @param modelColumnIndex index of column in table model

     * @return table column object or null if no such column in this column model

     */

    public TableColumn getColumnByModelIndex(int modelColumnIndex) {

        for (int columnIndex = 0; columnIndex < allTableColumns.size(); ++columnIndex) {

            TableColumn column = allTableColumns.get(columnIndex);

            if (column.getModelIndex() == modelColumnIndex) {

                return column;

            }

        }

        return null;

    }

    /**

     * Checks wether the specified column is currently visible.

     *

     * @param aColumn column to check

     * @return visibility of specified column (false if there is no such column at all. [It's not

     *         visible, right?])

     */

    public boolean isColumnVisible(TableColumn aColumn) {

        return (tableColumns.indexOf(aColumn) >= 0);

    }

    /**

     * Append <code>column</code> to the right of exisiting columns. Posts <code>columnAdded</code>

     * event.

     *

     * @param column The column to be added

     * @see #removeColumn

     * @exception IllegalArgumentException if <code>column</code> is <code>null</code>

     */

    public void addColumn(TableColumn column) {

        allTableColumns.add(column);

        super.addColumn(column);

    }

    /**

     * Removes <code>column</code> from this column model. Posts <code>columnRemoved</code> event.

     * Will do nothing if the column is not in this model.

     *

     * @param column the column to be added

     * @see #addColumn

     */

    public void removeColumn(TableColumn column) {

        int allColumnsIndex = allTableColumns.indexOf(column);

        if (allColumnsIndex != -1) {

            allTableColumns.remove(allColumnsIndex);

        }

        super.removeColumn(column);

    }

    /**

     * Moves the column from <code>oldIndex</code> to <code>newIndex</code>. Posts

     * <code>columnMoved</code> event. Will not move any columns if <code>oldIndex</code> equals

     * <code>newIndex</code>.

     *

     * @param oldIndex index of column to be moved

     * @param newIndex new index of the column

     * @exception IllegalArgumentException if either <code>oldIndex</code> or <code>newIndex</code>

     *            are not in [0, getColumnCount() - 1]

     */

    public void moveColumn(int oldIndex, int newIndex) {

        if ((oldIndex < 0) || (oldIndex >= getColumnCount()) || (newIndex < 0) || (newIndex >= getColumnCount()))

            throw new IllegalArgumentException("moveColumn() - Index out of range");

        TableColumn fromColumn = tableColumns.get(oldIndex);

        TableColumn toColumn = tableColumns.get(newIndex);

        int allColumnsOldIndex = allTableColumns.indexOf(fromColumn);

        int allColumnsNewIndex = allTableColumns.indexOf(toColumn);

        if (oldIndex != newIndex) {

            allTableColumns.remove(allColumnsOldIndex);

            allTableColumns.add(allColumnsNewIndex, fromColumn);

        }

        super.moveColumn(oldIndex, newIndex);

    }

    /**

     * Returns the total number of columns in this model.

     *

     * @param onlyVisible if set only visible columns will be counted

     * @return the number of columns in the <code>tableColumns</code> array

     * @see #getColumns

     */

    public int getColumnCount(boolean onlyVisible) {

        return getColumnsFast(onlyVisible).size();

    }

    /**

     * Returns all the columns in the model.

     *

     * @param onlyVisible if set all invisible columns will be missing from the result.

     * @return the columns in the model

     */

    public List<TableColumn> getColumns(boolean onlyVisible) {

        return Collections.unmodifiableList(getColumnsFast(onlyVisible));

    }

    private final List<TableColumn> getColumnsFast(boolean onlyVisible) {

        return onlyVisible ? tableColumns : allTableColumns;

    }

    /**

     * Returns the position of the first column whose identifier equals <code>identifier</code>.

     * Position is the the index in all visible columns if <code>onlyVisible</code> is true or else

     * the index in all columns.

     *

     * @param identifier the identifier object to search for

     * @param onlyVisible if set searches only visible columns

     *

     * @return the index of the first column whose identifier equals <code>identifier</code>

     *

     * @exception IllegalArgumentException if <code>identifier</code> is <code>null</code>, or if no

     *            <code>TableColumn</code> has this <code>identifier</code>

     * @see #getColumn

     */

    public int getColumnIndex(Object identifier, boolean onlyVisible) {

        if (identifier == null) {

            throw new IllegalArgumentException("Identifier is null");

        }

        List<TableColumn> columns = getColumnsFast(onlyVisible);

        int noColumns = columns.size();

        TableColumn column;

        for (int columnIndex = 0; columnIndex < noColumns; ++columnIndex) {

            column = columns.get(columnIndex);

            if (identifier.equals(column.getIdentifier()))

                return columnIndex;

        }

        throw new IllegalArgumentException("Identifier not found");

    }

    /**

     * Returns the <code>TableColumn</code> object for the column at <code>columnIndex</code>.

     *

     * @param columnIndex the index of the column desired

     * @param onlyVisible if set columnIndex is meant to be relative to all visible columns only

     *        else it is the index in all columns

     *

     * @return the <code>TableColumn</code> object for the column at <code>columnIndex</code>

     */

    public TableColumn getColumn(int columnIndex, boolean onlyVisible) {

        return getColumnsFast(onlyVisible).get(columnIndex);

    }

    @Override

    public TableColumn getColumn(int columnIndex) {

        if (columnIndex < 0) {

            // Fix OpenJDK with FlatUI

            columnIndex = 0;

        }

        return super.getColumn(columnIndex);

    }

}