Application: gvSIG desktop

package org.gvsig.fmap.dal.swing.impl.featuretable;

import java.math.BigDecimal;

import java.util.ArrayList;

import java.util.Date;

import java.util.Iterator;

import java.util.List;

import java.util.logging.Level;

import javax.swing.JTable;

import javax.swing.table.AbstractTableModel;

import javax.swing.table.DefaultTableCellRenderer;

import javax.swing.table.TableCellRenderer;

import org.gvsig.fmap.dal.complements.Search;

import org.gvsig.fmap.dal.exception.DataException;

import org.gvsig.fmap.dal.feature.EditableFeatureAttributeDescriptor;

import org.gvsig.fmap.dal.feature.Feature;

import org.gvsig.fmap.dal.feature.FeatureAttributeDescriptor;

import org.gvsig.fmap.dal.feature.FeatureStore;

import org.gvsig.fmap.dal.feature.FeatureType;

import org.gvsig.fmap.dal.feature.paging.FacadeOfAFeaturePagingHelper;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dataTypes.Coercion;

import org.gvsig.tools.dataTypes.CoercionException;

import org.gvsig.tools.dataTypes.DataTypes;

import org.gvsig.tools.dispose.Disposable;

import org.gvsig.tools.dispose.DisposeUtils;

import org.gvsig.tools.logger.FilteredLogger;

import org.gvsig.tools.util.UnmodifiableBasicList;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 *

 * @author jjdelcerro

 */

public class SimpleFeaturesTableModel

        extends AbstractTableModel

        implements UnmodifiableBasicList<Feature>, Disposable {

    private static final Logger LOGGER = LoggerFactory.getLogger(SimpleFeaturesTableModel.class);

    private static class FeatureAttributeCellRenderer extends DefaultTableCellRenderer {

        private final FeatureAttributeDescriptor descriptor;

        private final Coercion toStr;

        public FeatureAttributeCellRenderer(FeatureAttributeDescriptor descriptor) {

            this.descriptor = descriptor;

            this.toStr = ToolsLocator.getDataTypesManager().get(DataTypes.STRING).getCoercion();

        }

        @Override

        protected void setValue(Object value) {

            if (value == null) {

                setText("");

            } else {

                try {

                    value = toStr.coerce(value);

                } catch (CoercionException ex) {

                    LOGGER.debug("Can't coerce value to string.", ex);

                }

                setText((String) value);

            }

        }

    }

    private List<Feature> features;

    private final List<String> columnNames;

    private final FeatureType featureType;

    private FilteredLogger logger;

    private boolean errors;

    public static void setCellRenderers(JTable table) {

        if (!(table.getModel() instanceof SimpleFeaturesTableModel)) {

            return;

        }

        SimpleFeaturesTableModel model = (SimpleFeaturesTableModel) table.getModel();

        for (String columnName : model.columnNames) {

            try {

                FeatureAttributeDescriptor descriptor = model.featureType.getAttributeDescriptor(columnName);

                if (descriptor == null) {

                    descriptor = model.featureType.getExtraColumns().get(columnName);

                }

                switch (descriptor.getType()) {

                    case DataTypes.BYTEARRAY:

                        table.setDefaultRenderer(byte[].class, new FeatureAttributeCellRenderer(descriptor));

                        break;

                    case DataTypes.DATE:

                        table.setDefaultRenderer(java.sql.Date.class, new FeatureAttributeCellRenderer(descriptor));

                        break;

                    case DataTypes.TIME:

                        table.setDefaultRenderer(java.sql.Time.class, new FeatureAttributeCellRenderer(descriptor));

                        break;

                    case DataTypes.TIMESTAMP:

                        table.setDefaultRenderer(java.util.Date.class, new FeatureAttributeCellRenderer(descriptor));

                        table.setDefaultRenderer(java.sql.Timestamp.class, new FeatureAttributeCellRenderer(descriptor));

                        break;

                    case DataTypes.FLOAT:

                        table.setDefaultRenderer(Float.class, new FeatureAttributeCellRenderer(descriptor));

                        break;

                    case DataTypes.DECIMAL:

                        table.setDefaultRenderer(BigDecimal.class, new FeatureAttributeCellRenderer(descriptor));

                        break;

                    case DataTypes.DOUBLE:

                        table.setDefaultRenderer(Double.class, new FeatureAttributeCellRenderer(descriptor));

                        break;

                }

            } catch (Exception ex) {

                throw new RuntimeException("Not able to get type of descriptor for column", ex);

            }

        }

    }

    public SimpleFeaturesTableModel(FeatureStore store) throws DataException {

        this(store.getDefaultFeatureType(), null, store.getFeatures());

    }

    public SimpleFeaturesTableModel(FeatureType featureType) {

        this(featureType, null, null);

        this.logger = new FilteredLogger(LOGGER, "SimpleFeaturesTableModel", 10);

    }

    public SimpleFeaturesTableModel(FeatureType featureType, List<String> columnNames, List<Feature> features) {

        this.logger = new FilteredLogger(LOGGER, "SimpleFeaturesTableModel", 10);

        this.features = features;

        this.featureType = featureType;

        this.errors = false;

        if (columnNames == null || columnNames.isEmpty()) {

            this.columnNames = new ArrayList<>();

            Search search = (Search) ToolsLocator.getComplementsManager().get(

                    Search.COMPLEMENT_MANE, featureType

            );

            List<Search.OrderedAttribute> attributos = search.getOrderedAttributes(

                    Search.BASIC_TYPES_FILTER,

                    Search.STR_INT_LONG_LABEL_ORDER,

                    12

            );

            for (Search.OrderedAttribute attrdesc : attributos) {

                this.columnNames.add(attrdesc.getDescriptor().getName());

            }

        } else {

            this.columnNames = columnNames;

        }

    }

    public List<Feature> getFeatures() {

        return this.features;

    }

    @Override

    public int getRowCount() {

        if (this.features == null) {

            return 0;

        }

        try {

            return this.features.size();

        } catch (Throwable ex) {

            this.errors = true;

            LOGGER.warn("Can't calculate row count.", ex);

            return 0;

        }

    }

    public boolean hasErrors() {

        return this.errors;

    }

    @Override

    public int getColumnCount() {

        return this.columnNames.size();

    }

    @Override

    public String getColumnName(int columnIndex) {

        String attrName = this.columnNames.get(columnIndex);

        if (this.featureType == null) {

            return attrName;

        }

        FeatureAttributeDescriptor attrdesc = this.featureType.getAttributeDescriptor(attrName);

        if (attrdesc == null) {

            EditableFeatureAttributeDescriptor extraCol = this.featureType.getExtraColumns().get(attrName);

            if (extraCol != null) {

                return extraCol.getLocalizedShortLabel();

            }

            if (attrName == null) {

                return "Column" + columnIndex;

            }

            return attrName;

        }

        return attrdesc.getLocalizedShortLabel();

    }

    @Override

    public Class<?> getColumnClass(int columnIndex) {

        if (this.featureType == null) {

            return String.class;

        }

        try {

            String attrName = this.columnNames.get(columnIndex);

            FeatureAttributeDescriptor attrdesc = this.featureType.getAttributeDescriptor(attrName);

            if (attrdesc == null) {

                int extraIndex = featureType.getExtraColumns().getIndexOf(attrName);

                if (extraIndex != -1) {

                    attrdesc = featureType.getExtraColumns().get(extraIndex);

                }

            }

            if (attrdesc == null) {

                return String.class;

            }

            if (attrdesc.isForeingKey() && attrdesc.getForeingKey().isClosedList()) {

                return String.class;

            }

            Class theClass = attrdesc.getDataType().getDefaultClass();

            if (theClass == null) {

                return String.class;

            }

            return theClass;

        } catch (Exception ex) {

            return String.class;

        }

    }

    @Override

    public boolean isCellEditable(int rowIndex, int columnIndex) {

        return false;

    }

    @Override

    public Feature get(int position) {

        if (this.features == null) {

            return null;

        }

        Feature feature = this.features.get(position);

        return feature;

    }

    @Override

    public Object getValueAt(int rowIndex, int columnIndex) {

        if (this.features == null) {

            return null;

        }

        try {

            Feature feature = this.features.get(rowIndex);

            String attrName = this.columnNames.get(columnIndex);

            Object value = null;

            value = feature.get(attrName);

            FeatureAttributeDescriptor attrdesc = this.featureType.getAttributeDescriptor(attrName);

            if (attrdesc != null) {

                if (attrdesc.isForeingKey() && attrdesc.getForeingKey().isClosedList()) {

                    value = attrdesc.getForeingKey().getLabelForValue(value);

                }

            }

            return value;

        } catch (Throwable th) {

            this.errors = true;

            logger.warn("Can't get cell value at " + rowIndex + ", " + columnIndex + ".", th);

            return null;

        }

    }

    @Override

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

    }

    @Override

    public List<Feature> toList() {

        return this.features;

    }

    @Override

    public boolean isEmpty() {

        return this.features.isEmpty();

    }

    @Override

    public int size() {

        return this.features.size();

    }

    @Override

    public Iterator<Feature> iterator() {

        return this.features.iterator();

    }

    @Override

    public void dispose() {

        if (this.features != null) {

            DisposeUtils.disposeQuietly(((FacadeOfAFeaturePagingHelper) features).getFeaturePagingHelper());

            this.features = null;

        }

        this.features = null;

    }

}