Application: gvSIG desktop

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

import java.util.ArrayList;

import java.util.Iterator;

import java.util.List;

import javax.swing.table.AbstractTableModel;

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.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 List<Feature> features;

        private final List<String> columnNames;

        private final FeatureType featureType;

        private FilteredLogger logger;

        private boolean errors;

        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;

    }

}