Application: gvSIG desktop

/* gvSIG. Geographic Information System of the Valencian Government

 *

 * Copyright (C) 2007-2008 Infrastructures and Transports Department

 * of the Valencian Gobernment (CIT)

 * 

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 2

 * of the License, or (at your option) any later version.

 * 

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 * 

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, 

 * MA  02110-1301, USA.

 * 

 */

/*

 * AUTHORS (In addition to CIT):

 * 2008 {DiSiD Technologies}  {Create a JTable TableModel for a FeatureCollection}

 */

package org.gvsig.fmap.data.feature.swing.table;

import javax.swing.table.AbstractTableModel;

import org.gvsig.fmap.data.DataException;

import org.gvsig.fmap.data.ReadException;

import org.gvsig.fmap.data.feature.*;

import org.gvsig.fmap.data.feature.paging.FeaturePagingHelper;

import org.gvsig.fmap.data.feature.paging.FeaturePagingHelperImpl;

/**

 * TableModel to access data of a FeatureCollection.

 * 

 * @author <a href="mailto:cordin@disid.com">C?sar Ordi?ana</a>

 */

public class FeatureTableModel extends AbstractTableModel {

    private static final long serialVersionUID = -2488157521902851301L;

    private FeaturePagingHelper helper;

    /**

     * Constructs a TableModel from a FeatureCollection, with the default page

     * size.

     * 

     * @param featureCollection

     *            to extract data from

     * @throws ReadException

     *             if there is an error reading data from the FeatureStore

     */

    public FeatureTableModel(FeatureStore featureStore,

            FeatureQuery featureQuery) throws ReadException {

        this(featureStore, featureQuery, FeaturePagingHelper.DEFAULT_PAGE_SIZE);

    }

    /**

     * Constructs a TableModel from a FeatureCollection, and a given page size.

     * 

     * @param featureCollection

     *            to extract data from

     * @param pageSize

     *            the number of elements per page data

     * @throws ReadException

     *             if there is an error reading data from the FeatureStore

     */

    public FeatureTableModel(FeatureStore featureStore,

            FeatureQuery featureQuery, int pageSize) throws ReadException {

        this(new FeaturePagingHelperImpl(featureStore, featureQuery, pageSize));

    }

    /**

     * Constructs a TableModel from a FeatureCollection and a Paging helper.

     * 

     * @param featureCollection

     *            to extract data from

     * @param helper

     *            the paging helper

     * @throws ReadException

     *             if there is an error reading data from the FeatureStore

     */

    public FeatureTableModel(FeaturePagingHelper helper) {

        this.helper = helper;

        initialize();

    }

    public int getColumnCount() {

        // Return the number of fields of the Features

        FeatureType featureType = getFeatureType();

        return featureType.getFields().length;

    }

    public int getRowCount() {

        // Return the total size of the collection

        return getHelper().getTotalSize();

    }

    public Object getValueAt(int rowIndex, int columnIndex) {

        // Get the Feature at row "rowIndex", and return the value of the

        // attribute at "columnIndex"

        Feature feature = getFeatureAt(rowIndex);

        return getFeatureValue(feature, columnIndex);

    }

    @SuppressWarnings("unchecked")

    public Class getColumnClass(int columnIndex) {

        // Return the class of the FeatureAttributeDescriptor for the value

        FeatureAttributeDescriptor attributeDesc = getAttributeDescriptor(columnIndex);

        Class clazz = attributeDesc.getObjectClass();

        return (clazz == null ? super.getColumnClass(columnIndex) : clazz);

    }

    public String getColumnName(int column) {

        // Return the Feature attribute name

        FeatureAttributeDescriptor attributeDesc = getAttributeDescriptor(column);

        return attributeDesc.getName();

    }

    @Override

    public boolean isCellEditable(int rowIndex, int columnIndex) {

        return getFeatureStore().isEditing();

    }

    /**

     * TODO: the current implementation does not work, update to the last API

     * changes for Feature edition.

     */

    @Override

    public void setValueAt(Object value, int rowIndex, int columnIndex) {

        // Get the feature at rowIndex

        Feature feature = getFeatureAt(rowIndex);

        // Only set the value if the feature exists

        if (feature != null) {

            // We only need to update if the value to set is not equal to the

            // current value

            Object currentValue = getFeatureValue(feature, columnIndex);

            if (value != currentValue

                    || (value != null && !value.equals(currentValue))) {

                try {

                    // getFeatureStore().startEditing();

                    //                    

                    // EditableFeature editable = feature.getEditableFeature();

                    // editable.set(columnIndex, value);

                    //                    

                    // getFeatureStore().update(editable);

                    // getFeatureStore().finishEditing();

                    getFeatureStore().startEditing();

                    feature.editing();

                    setFeatureValue(feature, columnIndex, value);

                    getFeatureStore().update(feature);

                    // getHelper().reload();

                    // TODO: REVISAR

                    // getHelper().setFeatureCollection(

                    // (FeatureCollection) getFeatureStore()

                    // .getDataCollection(getFeatureQuery()));

                    fireTableCellUpdated(rowIndex, columnIndex);

                } catch (DataException ex) {

                    throw new SetFeatureValueException(rowIndex, columnIndex,

                            value, ex);

                }

            }

        }

    }

    /**

     * Returns a reference to the Paging Helper used to load the data from the

     * DataStore.

     * 

     * @return the paging helper

     */

    public FeaturePagingHelper getHelper() {

        return helper;

    }

    /**

     * Initialize the TableModel

     */

    protected void initialize() {

        // Nothing to do

    }

    /**

     * Returns the value for a row position.

     * 

     * @param rowIndex

     *            the row position

     * @return the Feature

     */

    protected Feature getFeatureAt(int rowIndex) {

        return getHelper().getFeatureAt(rowIndex);

    }

    /**

     * Returns the value of a Feature attribute, at the given position.

     * 

     * @param feature

     *            the feature to get the value from

     * @param columnIndex

     *            the Feature attribute position

     * @return the value

     */

    protected Object getFeatureValue(Feature feature, int columnIndex) {

        return feature.get(columnIndex);

    }

    /**

     * Sets the value of an Feature attribute at the given position.

     * 

     * @param feature

     *            the feature to update

     * @param columnIndex

     *            the attribute position

     * @param value

     *            the value to set

     * @throws IsNotFeatureSettingException

     *             if there is an error setting the value

     */

    protected void setFeatureValue(Feature feature, int columnIndex,

            Object value) throws IsNotFeatureSettingException {

        feature.set(columnIndex, value);

    }

    /**

     * Returns the FeatureCollection used to get the data.

     * 

     * @return the FeatureCollection

     */

    protected FeatureCollection getFeatureCollection() {

        return getHelper().getFeatureCollection();

    }

    /**

     * Returns the FeatureStore of the Collection.

     * 

     * @return the FeatureStore

     */

    protected FeatureStore getFeatureStore() {

        return getHelper().getFeatureStore();

    }

    /**

     * Returns the FeatureQuery used to get the Features.

     * 

     * @return the FeatureQuery

     */

    protected FeatureQuery getFeatureQuery() {

        return getHelper().getFeatureQuery();

    }

    /**

     * Returns the type of the features.

     */

    private FeatureType getFeatureType() {

        return getFeatureCollection().getFeatureType();

    }

    /**

     * Returns the descriptor of a Feature attribute.

     */

    private FeatureAttributeDescriptor getAttributeDescriptor(int columnIndex) {

        return getFeatureType().getByOrder(columnIndex);

    }

}

/* gvSIG. Geographic Information System of the Valencian Government

 *

 * Copyright (C) 2007-2008 Infrastructures and Transports Department

 * of the Valencian Gobernment (CIT)

 * 

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 2

 * of the License, or (at your option) any later version.

 * 

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 * 

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, 

 * MA  02110-1301, USA.

 * 

 */

/*

 * AUTHORS (In addition to CIT):

 * 2008 {DiSiD Technologies}  {{Task}}

 */

package org.gvsig.fmap.data.feature.swing.table;

import java.util.*;

import org.gvsig.fmap.data.ReadException;

import org.gvsig.fmap.data.feature.*;

import org.gvsig.fmap.data.feature.paging.FeaturePagingHelper;

/**

 * Extends the FeatureTableModel to add more configurable options, like the

 * visible columns, column name aliases and row order.

 * 

 * @author <a href="mailto:cordin@disid.com">C?sar Ordi?ana</a>

 */

public class ConfigurableFeatureTableModel extends FeatureTableModel {

    private static final long serialVersionUID = -8223987814719746492L;

    private List<String> columnNames;

    private List<String> visibleColumnNames;

    private Map<String, String> name2Alias;

    /**

     * @see FeatureTableModel#FeatureTableModel(FeatureStore, FeatureQuery)

     */

    public ConfigurableFeatureTableModel(FeatureStore featureStore,

            FeatureQuery featureQuery) throws ReadException {

        super(featureStore, featureQuery);

    }

    /**

     * @see FeatureTableModel#FeatureTableModel(FeatureStore, FeatureQuery, int)

     */

    public ConfigurableFeatureTableModel(FeatureStore featureStore,

            FeatureQuery featureQuery, int pageSize) throws ReadException {

        super(featureStore, featureQuery, pageSize);

    }

    /**

     * @see FeatureTableModel#FeatureTableModel(FeaturePagingHelper)

     */

    public ConfigurableFeatureTableModel(FeaturePagingHelper helper) {

        super(helper);

    }

    @Override

    public int getColumnCount() {

        return visibleColumnNames.size();

    }

    @Override

    public String getColumnName(int column) {

        int realIndex = getRealColumnIndex(column);

        String realName = super.getColumnName(realIndex);

        return getAliasForColumn(realName);

    }

    /**

     * Sets the visibility of a table column.

     * 

     * @param columnIndex

     *            the index of the column to update

     * @param visible

     *            if the column will be visible or not

     */

    public void setVisible(String name, boolean visible) {

        // If we don't have already the column as visible,

        // add to the list, without order, and recreate

        // the visible columns list in the original order

        if (visible && !visibleColumnNames.contains(name)) {

            visibleColumnNames.add(name);

            setVisibleColumns(visibleColumnNames);

        } else {

            visibleColumnNames.remove(name);

            fireTableStructureChanged();

        }

    }

    /**

     * Sets the current visible columns list, in the original order.

     * 

     * @param names

     *            the names of the columns to set as visible

     */

    public void setVisibleColumns(List<String> names) {

        // Recreate the visible column names list

        // to maintain the original order

        visibleColumnNames = new ArrayList<String>(names.size());

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

            String columnName = columnNames.get(i);

            if (names.contains(columnName)) {

                visibleColumnNames.add(columnName);

            }

        }

        fireTableStructureChanged();

    }

    /**

     * Changes all columns to be visible.

     */

    public void setAllVisible() {

        visibleColumnNames.clear();

        visibleColumnNames.addAll(columnNames);

        fireTableStructureChanged();

    }

    /**

     * Sets the alias for a column.

     * 

     * @param name

     *            the name of the column

     * @param alias

     *            the alias for the column

     */

    public void setAlias(String name, String alias) {

        name2Alias.put(name, alias);

        fireTableStructureChanged();

    }

    public void orderByColumn(String name, boolean ascending)

            throws ReadException {

        String order = ascending ? name.concat(" ASC") : name.concat(" DESC"); 

        getHelper().getFeatureQuery().setOrder(order);

        getHelper().reload();

        fireTableDataChanged();

    }

    @Override

    protected void initialize() {

        super.initialize();

        initializeVisibleColumns();

        initializeAliases();

    }

    /**

     * Initializes the table name aliases.

     */

    private void initializeAliases() {

        int columns = super.getColumnCount();

        name2Alias = new HashMap<String, String>(columns);

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

            String columnName = super.getColumnName(i);

            name2Alias.put(columnName, columnName);

        }

    }

    /**

     * Initializes the table visible columns.

     */

    protected void initializeVisibleColumns() {

        int columns = super.getColumnCount();

        columnNames = new ArrayList<String>(columns);

        visibleColumnNames = new ArrayList<String>(columns);

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

            String columnName = super.getColumnName(i);

            columnNames.add(columnName);

            visibleColumnNames.add(columnName);

        }

    }

    /**

     * Returns the alias for the name of a column.

     * 

     * @param name

     *            of the column

     * @return the alias

     */

    protected String getAliasForColumn(String name) {

        return name2Alias.get(name);

    }

    /**

     * Returns if a column is visible.

     * 

     * @param name

     *            the name of the column

     * @return if the column is visible

     */

    protected boolean isVisible(String name) {

        return visibleColumnNames.contains(name);

    }

    /**

     * Returns the real position of a column.

     * 

     * @param columnIndex

     *            the current visible column index

     * @return the real column index

     */

    protected int getRealColumnIndex(int columnIndex) {

        String columnName = visibleColumnNames.get(columnIndex);

        return columnNames.indexOf(columnName);

    }

    @Override

    protected Object getFeatureValue(Feature feature, int columnIndex) {

        int realColumnIndex = getRealColumnIndex(columnIndex);

        return super.getFeatureValue(feature, realColumnIndex);

    }

    @Override

    protected void setFeatureValue(Feature feature, int columnIndex,

            Object value) throws IsNotFeatureSettingException {

        int realColumnIndex = getRealColumnIndex(columnIndex);

        super.setFeatureValue(feature, realColumnIndex, value);

    }

}