Application: gvSIG desktop

import javax.swing.table.TableColumn;

import javax.swing.table.TableColumnModel;

import javax.swing.table.TableModel;

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

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

import org.gvsig.fmap.dal.swing.FeatureTableModel;

import org.gvsig.fmap.dal.swing.impl.featuretable.table.DefaultFeatureTableModel;

import org.gvsig.fmap.dal.swing.impl.featuretable.table.renders.FeatureCellRenderer;

import org.gvsig.fmap.dal.swing.impl.featuretable.table.renders.FormattedCellRenderer;

import org.gvsig.fmap.dal.swing.impl.featuretable.table.renders.JToggleButtonHeaderCellRenderer;

import org.gvsig.tools.observer.Observable;

import org.gvsig.tools.observer.Observer;

    public void addColumnSelectionListener(ActionListener listener) {

       this.columnSelectionListeners.add(listener);

    }

    public void fireColumnSelection(ActionEvent e) {

        for( ActionListener listener : this.columnSelectionListeners ) {

            try {

                listener.actionPerformed(e);

            } catch(Exception ex) {

            }

        }

    }

        }

        this.setAutoResizeMode(JTable.AUTO_RESIZE_LAST_COLUMN);

    }

    @Override

    public void setModel(TableModel dataModel) {

        super.setModel(dataModel);

    }

    @Override

    public int getSelectedColumnCount() {

        return headerCellRenderer.getSelectedColumns().length;

    public int[] getSelectedColumns() {

        return headerCellRenderer.getSelectedColumns();

    }

    @Override

    public void tableChanged(TableModelEvent e) {

        // Clear the header selection

 * AUTHORS (In addition to CIT):

 * 2008 {DiSiD Technologies}  {{Task}}

 */

import java.util.Collections;

import java.util.Map;

/**

 * Exception thrown when there is an error while getting a Feature in a

 * position.

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

 */

public class GetFeatureAtException extends BaseRuntimeException {

    /**

     * Creates a new Exception when getting a Feature.

     * @param rowIndex

     *            the position of the Feature

     */

    /**

     * Creates a new Exception when getting a Feature.

     * @param rowIndex

     *            the position of the Feature

     * @param cause

 * AUTHORS (In addition to CIT):

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

 */

import javax.swing.table.DefaultTableCellRenderer;

/**

 * Simple renderer for cells of type {@link Geometry} .

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

 */

public class GeometryCellRenderer extends DefaultTableCellRenderer {

 * AUTHORS (In addition to CIT):

 * 2008 {DiSiD Technologies}  {{Task}}

 */

import org.gvsig.tools.exception.BaseRuntimeException;

/**

 * Exception thrown when there is an error while converting a Geometry to WKT

 * into a table cell.

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

 */

public class GeometryToWKTException extends BaseRuntimeException {

    /**

     * Creates a new Exception when getting a Geometry cell as WKT.

     */

    public GeometryToWKTException() {

        super(MESSAGE, KEY, serialVersionUID);

    /**

     * Creates a new Exception when getting a Geometry cell as WKT.

     * @param cause

     *            the original Throwable

     */

 * AUTHORS (In addition to CIT):

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

 */

import org.gvsig.fmap.dal.swing.impl.featuretable.table.renders.TextAreaCellRenderer;

import org.gvsig.fmap.geom.Geometry;

/**

 * Renderer for cells of type {@link Geometry}, showing it in WKT format.

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

 */

public class GeometryWKTCellRenderer extends TextAreaCellRenderer {

    private static final Logger logger = LoggerFactory.getLogger(GeometryWKTCellRenderer.class);

    private static final long serialVersionUID = -2470239399517077869L;

    public static final int DEFAULT_MAX_WKT_LENGTH = 800;

    public static final int DEFAULT_MAX_ROW_HEIGHT = 80;

    /**

    /**

     * Creates a new GeometryWKTCellRenderer.

     * @param maxWKTLength

     *            the maximum WTK length to be rendered.

     * @param maxRowHeight

import java.util.List;

import java.util.Locale;

import java.util.Map;

import javax.swing.SwingUtilities;

import javax.swing.Timer;

import javax.swing.event.TableModelEvent;

import javax.swing.table.AbstractTableModel;

import org.gvsig.fmap.dal.DataTypes;

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

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

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

import org.gvsig.fmap.dal.feature.exception.ConcurrentDataModificationException;

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

import org.gvsig.tools.exception.BaseException;

import org.gvsig.tools.observer.ComplexNotification;

import org.gvsig.tools.observer.ComplexObserver;

import org.gvsig.tools.observer.Observable;

public class DefaultFeatureTableModel extends AbstractTableModel implements org.gvsig.fmap.dal.swing.FeatureTableModel,  ComplexObserver  {

    private static final long serialVersionUID = -8223987814719746492L;

    private static final Logger logger = LoggerFactory.getLogger(DefaultFeatureTableModel.class);

    private List<String> columnNames;

    private Map<String,String> patterns = null;

    private final FeaturePagingHelper featurePager;

    private EditableFeature editableFeature;

    private boolean selectionLocked=false;

    private final DelayAction delayAction = new DelayAction();

    private void initialize() {

        this.getFeatureStore().addObserver(this);

        int columns = this.getOriginalColumnCount();

        // Initilize visible columns

            }

        }

        visibleColumnNamesOriginal = new ArrayList<>(visibleColumnNames);

        // Initialize alias

        name2Alias = new HashMap<>(columns);

        name2AliasOriginal = new HashMap<>(columns);

    private void initializeFormatingPatterns() {

        int columns = this.getOriginalColumnCount();

        this.patterns = new HashMap<>();

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

            FeatureAttributeDescriptor descriptor = this.getInternalColumnDescriptor(i);

                this.patterns.put(columnName,null);

            }

        }

    }

    private void updatePagerWithHiddenColums() {

        FeatureQuery query = this.getFeaturePager().getFeatureQuery();

        if (this.getFeaturePager().getFeatureStore().isEditing()) {

            logger.warn("Can't reload paging-helper.", ex);

        }

    }

    @Override

    public FeaturePagingHelper getFeaturePager() {

        return this.featurePager;

    }

    @Override

    public FeatureQuery getFeatureQuery() {

        return this.getFeaturePager().getFeatureQuery();

    public FeatureType getFeatureType() {

        return this.getFeaturePager().getFeatureType();

    }

    @Override

    public FeatureStore getFeatureStore() {

        return this.getFeaturePager().getFeatureStore();

    @Override

    public Class<?> getColumnClass(int columnIndex) {

        int originalIndex = getOriginalColumnIndex(columnIndex);

        // Return the class of the FeatureAttributeDescriptor for the value

        FeatureAttributeDescriptor attributeDesc = this.getInternalColumnDescriptor(originalIndex);

        if (attributeDesc == null) {

        int originalIndex = getOriginalColumnIndex(columnIndex);

        return this.getInternalColumnDescriptor(originalIndex);

    }

    protected FeatureAttributeDescriptor getInternalColumnDescriptor(int columnIndex) {

        FeatureType featureType = getFeatureType();

        if( featureType == null ) {

        // Check if there is a new column name

        List<String> newColumns = new ArrayList<>();

        List<String> renamedColumnsNewName = new ArrayList<>();

        Iterator<FeatureAttributeDescriptor> attrIter = featureType.iterator();

        FeatureAttributeDescriptor fad ;

        EditableFeatureAttributeDescriptor efad ;

        String colName;

        while (attrIter.hasNext()) {

            fad = attrIter.next();

            colName = fad.getName();

            if (!columnNames.contains(colName)) {

                if (fad instanceof EditableFeatureAttributeDescriptor) {

                    /*

                     * If editable att descriptor,

                     * check original name

        name2Alias.keySet().retainAll(columnNames);

        name2AliasOriginal.keySet().retainAll(columnNames);

        getFeatureQuery().setFeatureType(featureType);

        reloadFeatures();

        //Selection must be locked to avoid losing it when the table is refreshed

        }finally{

            //The locked selection is unlocked.

            selectionLocked=false;

    }

            throw new FeaturesDataReloadException(ex);

        }

    }

    /**

     * keeps order of first parameter

     * @param lista

     * @param listb

     * @return

     */

    private List<String> intersectKeepOrder(List<String> lista, List<String> listb) {

        List<String> resp = new ArrayList<>();

        resp.addAll(lista);

        resp.retainAll(listb);

    public void setVisibleColumns(List<String> names) {

        // Recreate the visible column names list

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

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

            String columnName = columnNames.get(i);

    protected String[] getHiddenColumnNames() {

        List<String> hiddenColumns = new ArrayList<String>();

        hiddenColumns.addAll(columnNames);

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

            String columnName = visibleColumnNames.get(i);

            hiddenColumns.remove(columnName);

        }

        return (String[]) hiddenColumns.toArray(new String[hiddenColumns.size()]);

    }

    /**

     * Changes all columns to be visible.

     */

        Feature feature = getFeatureAt(rowIndex);

        return feature == null ? null : getFeatureValue(feature, columnIndex);

    }

    @Override

    public Feature getFeatureAt(int rowIndex) {

        try {

        } catch (BaseException ex) {

            throw new GetFeatureAtException(rowIndex, ex);

        }

    protected Object getFeatureValue(Feature feature, int columnIndex) {

        int realColumnIndex = getOriginalColumnIndex(columnIndex);

        return feature.get(realColumnIndex);

        editableFeature.set(realColumnIndex, value);

        return editableFeature;

    }

    public void acceptChanges() {

    	visibleColumnNamesOriginal = new ArrayList<>(visibleColumnNames);

    	name2AliasOriginal = new HashMap<>(name2Alias);

    }

    public void cancelChanges() {

    	visibleColumnNames = new ArrayList<>(visibleColumnNamesOriginal);

    	name2Alias = new HashMap<>(name2AliasOriginal);

    	fireTableStructureChanged();

    }

    @Override

    public String getColumnFormattingPattern(int column) {

        String columnName = this.visibleColumnNames.get(column);

        return this.getColumnFormattingPattern(columnName);

    }

    @Override

    public String getColumnFormattingPattern(String columnName) {

        String pattern = this.patterns.get(columnName);

        return pattern;

    }

    @Override

    public void setColumnFormattingPattern(String columnName, String pattern) {

        this.patterns.put(columnName,pattern);

    }

    @Override

    public Locale getLocaleOfData() {

        return this.localeOfData;

    }

    @Override

    public void setLocaleOfData(Locale locale) {

        this.localeOfData = locale;

    }

    public boolean isSelectionLocked() {

        return selectionLocked;

    @Override

    public boolean isSelectionUp() {

        return this.getFeaturePager().isSelectionUp();

    @Override

    public void setSelectionUp(boolean selectionUp) {

        this.getFeaturePager().setSelectionUp(selectionUp);

        fireTableChanged(new TableModelEvent(this, 0, getRowCount() - 1));

    }

    private class DelayAction extends Timer implements ActionListener, Runnable {

        private static final int STATE_NONE = 0;

        private static final int STATE_NEED_RELOADALL = 1;

        private static final int STATE_NEED_RELOAD_FEATURE_TYPE = 16;

        private static final int STATE_NEED_SELECTION_UP = 32;

        private static final int STATE_NEED_RELOAD_ALL_FEATURES=64;

        private static final long serialVersionUID = -5692569125344166705L;

        private int state = STATE_NONE;

            throw new RuntimeException("Can't get selection of the FeatureTableModel",ex);

        }

    }

}

import javax.swing.DefaultCellEditor;

import javax.swing.JOptionPane;

import javax.swing.JTable;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryManager;

import org.gvsig.i18n.Messages;

/**

 * Editor for cells of type Geometry in WKT format.

 * If the WKT to represent a Geometry is too big, editing is not allowed, as the

 * rendering of that big text is too slow.

 * </p>

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

 */

public class GeometryWKTCellEditor extends TextAreaCellEditor {

    public static final int DEFAULT_MAX_WKT_LENGTH = 10000;

    private static final long serialVersionUID = -2296004227902843851L;

    private int maxRowHeight;

    /**

    /**

     * Creates a new editor for Geometries in WKT format.

     * @param maxWKTLength

     *            the maximum WTK length allowed to be edited.

     * @param maxRowHeight