skrueger/geotools/StyledFeatureCollectionTableModel.java

/** SCHMITZM - This file is part of the java library of Martin O.J. Schmitz (SCHMITZM)

    This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version.
    This library 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 Lesser General Public License for more details.
    You should have received a copy of the GNU Lesser General Public License along with this library; if not, write to the Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110, USA

    Diese Bibliothek ist freie Software; Sie dürfen sie unter den Bedingungen der GNU Lesser General Public License, wie von der Free Software Foundation veröffentlicht, weiterverteilen und/oder modifizieren; entweder gemäß Version 2.1 der Lizenz oder (nach Ihrer Option) jeder späteren Version.
    Diese Bibliothek wird in der Hoffnung weiterverbreitet, daß sie nützlich sein wird, jedoch OHNE IRGENDEINE GARANTIE, auch ohne die implizierte Garantie der MARKTREIFE oder der VERWENDBARKEIT FÜR EINEN BESTIMMTEN ZWECK. Mehr Details finden Sie in der GNU Lesser General Public License.
    Sie sollten eine Kopie der GNU Lesser General Public License zusammen mit dieser Bibliothek erhalten haben; falls nicht, schreiben Sie an die Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110, USA.
 **/
package skrueger.geotools;

import java.util.Iterator;
import java.util.Map;
import java.util.Vector;

import org.apache.log4j.Logger;
import org.geotools.data.DefaultQuery;
import org.geotools.data.FeatureSource;
import org.geotools.data.Query;
import org.geotools.data.memory.MemoryDataStore;
import org.geotools.feature.AttributeType;
import org.geotools.feature.FeatureCollection;
import org.opengis.filter.Filter;

import schmitzm.geotools.gui.FeatureCollectionTableModel;
import skrueger.AttributeMetaData;
import skrueger.i8n.I8NUtil;
import skrueger.i8n.Translation;

import com.vividsolutions.jts.geom.Envelope;

/**
 * This class extends the the {@link FeatureCollectionTableModel} with the
 * functionalities of the {@link AttributeMetaData} of
 * {@linkplain StyledLayerInterface styled objects}.
 * <ul>
 * <li>column names are translated according to
 * {@link AttributeMetaData#getTitle()}</li>
 * <li>columns are hidden according to {@link AttributeMetaData#isVisible()()}</li>
 * </ul>
 * 
 * @author <a href="mailto:[email protected]">Martin Schmitz</a>
 *         (University of Bonn/Germany)
 */
public class StyledFeatureCollectionTableModel extends
                FeatureCollectionTableModel {
        final static private Logger LOGGER = Logger
                        .getLogger(StyledFeatureCollectionTableModel.class);
        /** Holds the data source as styled map. */
        protected StyledLayerInterface<?> layer = null;
        /** Contains only the visible elements of the {@link AttributeMetaData}-Map */
        protected Map<Integer, AttributeMetaData> visibleAMD = null;
        /** Holds the data source for the table as {@code FeatureSource}. */
        protected FeatureSource featureSource = null;
        /** Contains the complete {@link AttributeMetaData}-Map of the styled layer. */
        protected Map<Integer, AttributeMetaData> origAMD = null;
        /** Holds the current filter on the table */
        protected Filter filter = null;
        /** Holds the Bounds for all features. Only set once during the constructor **/
        protected Envelope bounds;

        
        /**
         * Creates a new table model for a styled map.
         * 
         * @param layer
         *            the styled layer
         */
        public StyledFeatureCollectionTableModel(
                        StyledFeatureCollectionInterface layer) {
                this(layer, Filter.INCLUDE);
        }

        /**
         * Creates a new table model for a styled map.
         * 
         * @param layer
         *            the styled layer
         * @param filter
         *            filter applied to the table
         */
        public StyledFeatureCollectionTableModel(
                        StyledFeatureCollectionInterface layer, Filter filter) {
                super();
                setFeatureCollection(layer, filter);
        }


        /**
         * Creates a new table model for a styled map.
         * 
         * @param layer
         *            the styled layer
         */
        public StyledFeatureCollectionTableModel(StyledFeaturesInterface layer) {
                this(layer, Filter.INCLUDE);
        }

        /**
         * Creates a new table model for a styled map.
         * 
         * @param layer
         *            the styled layer
         * @param filter
         *            filter applied to the table
         */
        public StyledFeatureCollectionTableModel(StyledFeaturesInterface layer,
                        Filter filter) {
                super();
                setFeatureCollection(layer, filter);
        }

        /**
         * Sets a new data source for the table.
         * 
         * @param fs
         *            the feature source
         * @param amd
         *            {@link AttributeMetaData}-Map to define the visible attributes
         *            and translation
         */
        protected void setFeatureSource(FeatureSource fs,
                        Map<Integer, AttributeMetaData> amd, Filter filter)
                        throws Exception {
                if (filter == null)
                        filter = Filter.INCLUDE;

                this.featureSource = fs;
                this.filter = filter;
                this.origAMD = amd;
                this.visibleAMD = null;

                FeatureCollection fc = null;
                if (fs != null) {

                        bounds = fs.getBounds();

                        Query query = new DefaultQuery(fs.getSchema().getTypeName(), filter);
                        if (amd != null) {
                                // determine the names of the visible Attributes
                                this.visibleAMD = StyledLayerUtil.getVisibleAttributeMetaData(
                                                amd, true);
                                Vector<String> visibleAttrNames = new Vector<String>();
                                // Add the column with the geometry (usually "the_geom")
                                visibleAttrNames.add(fs.getSchema().getDefaultGeometry()
                                                .getLocalName());
                                for (int attrIdx : visibleAMD.keySet()) {

                                        /**
                                         * If the user removed columns from the schema of the DBF
                                         * file, there might exist AttributeMetaData for columns
                                         * that don't exists. We check here to avoid an
                                         * ArrayOutOfIndex.
                                         */
                                        if (attrIdx < fs.getSchema().getAttributeCount()) {
                                                final AttributeType attributeTypeAtIdx = fs.getSchema()
                                                                .getAttributeType(attrIdx);
                                                visibleAttrNames.add(attributeTypeAtIdx.getLocalName());
                                        } else {
                                                LOGGER.warn("AttributeMetaData has been found for columnIdx="+attrIdx+", but fs.getSchema().getAttributeCount() = "+fs.getSchema().getAttributeCount()+". Ignored.");
                                        }
                                }

                                // create a query for the visible attributes
                                String[] properties = visibleAttrNames.toArray(new String[0]);

                                LOGGER.debug("Query contains the following attributes: "
                                                + visibleAttrNames);

                                query = new DefaultQuery(fs.getSchema().getTypeName(), filter,
                                                properties);
                        }
                        fc = fs.getFeatures(query);

                        // FAILS:!!!, even with query = new
                        // DefaultQuery(fs.getSchema().getTypeName(), filter);
                        // java.lang.UnsupportedOperationException: Unknown feature
                        // attribute: PQM_MOD
                        // at
                        // schmitzm.geotools.feature.FeatureOperationTree.evaluate(FeatureOperationTree.java:93)
                        // bounds = fc.getBounds();
                        // SK, 17.4.2009
                        //      
                        // System.out.println("Filter = "+filter);
                        // System.out.println("Size of FC = "+fc.size());
                        // System.out.println("anz att= "+fc.getNumberOfAttributes());
                }
                setFeatureCollection(fc);
        }

        /**
         * Converts the {@code StyledFeatureCollection} to a {@code FeatureSource}
         * and sets this as the new data source for the table.
         * 
         * @param fs
         *            the feature source
         * @param amd
         *            {@link AttributeMetaData}-Map to define the visible attributes
         *            and translation
         */
        public void setFeatureCollection(StyledFeaturesInterface layer,
                        Filter filter) {
                this.layer = layer;
                try {
                        if (layer == null)
                                setFeatureSource(null, null, null);
                        else {
                                FeatureCollection fc = layer.getFeatureCollection();
                                String fcName = fc.getSchema().getTypeName();
                                FeatureSource fs = new MemoryDataStore(fc)
                                                .getFeatureSource(fcName);
                                setFeatureSource(fs, layer.getAttributeMetaDataMap(), filter);
                        }
                } catch (Exception err) {
                        throw new RuntimeException(err);
                }
        }

        /**
         * Sets the {@code StyledFeatureCollection} as new data source for the
         * table.
         * 
         * @param fs
         *            the feature source
         * @param amd
         *            {@link AttributeMetaData}-Map to define the visible attributes
         *            and translation
         */
        public void setFeatureCollection(StyledFeatureSourceInterface layer,
                        Filter filter) {
                this.layer = layer;
                try {
                        if (layer == null)
                                setFeatureSource(null, null, null);
                        else
                                setFeatureSource(layer.getGeoObject(), layer
                                                .getAttributeMetaDataMap(), filter);
                } catch (Exception err) {
                        throw new RuntimeException(err);
                }
        }

        /**
         * Resets the filter for the table.
         * 
         * @param filter
         *            a filter
         */
        public void setFilter(Filter filter) {
                try {
                        setFeatureSource(this.featureSource, this.origAMD, filter);
                } catch (Exception err) {
                        LOGGER.error("Setting the filter of the table model", err);
                        throw new RuntimeException(err);
                }
        }

        /**
         * @return <code>Filter.INCLUDE</code> or the {@link Filter} applied to the
         *         Features
         */
        public Filter getFilter() {
                return this.filter;
        }

        /**
         * After calling {@code super.reorganize(.)} this method replaced the column
         * descriptions with the titles of the {@code AttributeMetaData}.
         * 
         * @param fireTableStructureChanged
         *            indicates whether a table event is initiated after reorganize
         */
        @Override
        protected void reorganize(boolean fireTableStructureChanged) {
                super.reorganize(false);
                // translate the column names
                if (visibleAMD != null) {
                        Iterator<Integer> keys = visibleAMD.keySet().iterator();
                        for (int i = 0; i < colNames.length && keys.hasNext(); i++) {
                                Translation title = visibleAMD.get(keys.next()).getTitle();
                                if (!I8NUtil.isEmpty(title)) {
                                        // System.out.println("set colname " + i + " to " +
                                        // title.toString());
                                        colNames[i] = title.toString();
                                }
                        }
                }
                if (fireTableStructureChanged)
                        fireTableStructureChanged();
        }

        /**
         * @return Cached bounds for the whole dataset (without applying the filter)
         *         or <code>null</code>
         */
        public Envelope getBounds() {
                return bounds;
        }
}
1	/** SCHMITZM - This file is part of the java library of Martin O.J. Schmitz (SCHMITZM)
2
3	This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version.
4	This library 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 Lesser General Public License for more details.
5	You should have received a copy of the GNU Lesser General Public License along with this library; if not, write to the Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110, USA
6
7	Diese Bibliothek ist freie Software; Sie dürfen sie unter den Bedingungen der GNU Lesser General Public License, wie von der Free Software Foundation veröffentlicht, weiterverteilen und/oder modifizieren; entweder gemäß Version 2.1 der Lizenz oder (nach Ihrer Option) jeder späteren Version.
8	Diese Bibliothek wird in der Hoffnung weiterverbreitet, daß sie nützlich sein wird, jedoch OHNE IRGENDEINE GARANTIE, auch ohne die implizierte Garantie der MARKTREIFE oder der VERWENDBARKEIT FÜR EINEN BESTIMMTEN ZWECK. Mehr Details finden Sie in der GNU Lesser General Public License.
9	Sie sollten eine Kopie der GNU Lesser General Public License zusammen mit dieser Bibliothek erhalten haben; falls nicht, schreiben Sie an die Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110, USA.
10	**/
11	package skrueger.geotools;
12
13	import java.util.Iterator;
14	import java.util.Map;
15	import java.util.Vector;
16
17	import org.apache.log4j.Logger;
18	import org.geotools.data.DefaultQuery;
19	import org.geotools.data.FeatureSource;
20	import org.geotools.data.Query;
21	import org.geotools.data.memory.MemoryDataStore;
22	import org.geotools.feature.AttributeType;
23	import org.geotools.feature.FeatureCollection;
24	import org.opengis.filter.Filter;
25
26	import schmitzm.geotools.gui.FeatureCollectionTableModel;
27	import skrueger.AttributeMetaData;
28	import skrueger.i8n.I8NUtil;
29	import skrueger.i8n.Translation;
30
31	import com.vividsolutions.jts.geom.Envelope;
32
33	/**
34	* This class extends the the {@link FeatureCollectionTableModel} with the
35	* functionalities of the {@link AttributeMetaData} of
36	* {@linkplain StyledLayerInterface styled objects}.
37	* <ul>
38	* <li>column names are translated according to
39	* {@link AttributeMetaData#getTitle()}</li>
40	* <li>columns are hidden according to {@link AttributeMetaData#isVisible()()}</li>
41	* </ul>
42	*
43	* @author <a href="mailto:[email protected]">Martin Schmitz</a>
44	* (University of Bonn/Germany)
45	*/
46	public class StyledFeatureCollectionTableModel extends
47	FeatureCollectionTableModel {
48	final static private Logger LOGGER = Logger
49	.getLogger(StyledFeatureCollectionTableModel.class);
50	/** Holds the data source as styled map. */
51	protected StyledLayerInterface<?> layer = null;
52	/** Contains only the visible elements of the {@link AttributeMetaData}-Map */
53	protected Map<Integer, AttributeMetaData> visibleAMD = null;
54	/** Holds the data source for the table as {@code FeatureSource}. */
55	protected FeatureSource featureSource = null;
56	/** Contains the complete {@link AttributeMetaData}-Map of the styled layer. */
57	protected Map<Integer, AttributeMetaData> origAMD = null;
58	/** Holds the current filter on the table */
59	protected Filter filter = null;
60	/ Holds the Bounds for all features. Only set once during the constructor /
61	protected Envelope bounds;
62
63
64
65	/**
66	* Creates a new table model for a styled map.
67	*
68	* @param layer
69	* the styled layer
70	*/
71	public StyledFeatureCollectionTableModel(
72	StyledFeatureCollectionInterface layer) {
73	this(layer, Filter.INCLUDE);
74	}
75
76	/**
77	* Creates a new table model for a styled map.
78	*
79	* @param layer
80	* the styled layer
81	* @param filter
82	* filter applied to the table
83	*/
84	public StyledFeatureCollectionTableModel(
85	StyledFeatureCollectionInterface layer, Filter filter) {
86	super();
87	setFeatureCollection(layer, filter);
88	}
89
90
91	/**
92	* Creates a new table model for a styled map.
93	*
94	* @param layer
95	* the styled layer
96	*/
97	public StyledFeatureCollectionTableModel(StyledFeaturesInterface layer) {
98	this(layer, Filter.INCLUDE);
99	}
100
101	/**
102	* Creates a new table model for a styled map.
103	*
104	* @param layer
105	* the styled layer
106	* @param filter
107	* filter applied to the table
108	*/
109	public StyledFeatureCollectionTableModel(StyledFeaturesInterface layer,
110	Filter filter) {
111	super();
112	setFeatureCollection(layer, filter);
113	}
114
115	/**
116	* Sets a new data source for the table.
117	*
118	* @param fs
119	* the feature source
120	* @param amd
121	* {@link AttributeMetaData}-Map to define the visible attributes
122	* and translation
123	*/
124	protected void setFeatureSource(FeatureSource fs,
125	Map<Integer, AttributeMetaData> amd, Filter filter)
126	throws Exception {
127	if (filter == null)
128	filter = Filter.INCLUDE;
129
130	this.featureSource = fs;
131	this.filter = filter;
132	this.origAMD = amd;
133	this.visibleAMD = null;
134
135	FeatureCollection fc = null;
136	if (fs != null) {
137
138	bounds = fs.getBounds();
139
140	Query query = new DefaultQuery(fs.getSchema().getTypeName(), filter);
141	if (amd != null) {
142	// determine the names of the visible Attributes
143	this.visibleAMD = StyledLayerUtil.getVisibleAttributeMetaData(
144	amd, true);
145	Vector<String> visibleAttrNames = new Vector<String>();
146	// Add the column with the geometry (usually "the_geom")
147	visibleAttrNames.add(fs.getSchema().getDefaultGeometry()
148	.getLocalName());
149	for (int attrIdx : visibleAMD.keySet()) {
150
151	/**
152	* If the user removed columns from the schema of the DBF
153	* file, there might exist AttributeMetaData for columns
154	* that don't exists. We check here to avoid an
155	* ArrayOutOfIndex.
156	*/
157	if (attrIdx < fs.getSchema().getAttributeCount()) {
158	final AttributeType attributeTypeAtIdx = fs.getSchema()
159	.getAttributeType(attrIdx);
160	visibleAttrNames.add(attributeTypeAtIdx.getLocalName());
161	} else {
162	LOGGER.warn("AttributeMetaData has been found for columnIdx="+attrIdx+", but fs.getSchema().getAttributeCount() = "+fs.getSchema().getAttributeCount()+". Ignored.");
163	}
164	}
165
166	// create a query for the visible attributes
167	String[] properties = visibleAttrNames.toArray(new String[0]);
168
169	LOGGER.debug("Query contains the following attributes: "
170	+ visibleAttrNames);
171
172	query = new DefaultQuery(fs.getSchema().getTypeName(), filter,
173	properties);
174	}
175	fc = fs.getFeatures(query);
176
177	// FAILS:!!!, even with query = new
178	// DefaultQuery(fs.getSchema().getTypeName(), filter);
179	// java.lang.UnsupportedOperationException: Unknown feature
180	// attribute: PQM_MOD
181	// at
182	// schmitzm.geotools.feature.FeatureOperationTree.evaluate(FeatureOperationTree.java:93)
183	// bounds = fc.getBounds();
184	// SK, 17.4.2009
185	//
186	// System.out.println("Filter = "+filter);
187	// System.out.println("Size of FC = "+fc.size());
188	// System.out.println("anz att= "+fc.getNumberOfAttributes());
189	}
190	setFeatureCollection(fc);
191	}
192
193	/**
194	* Converts the {@code StyledFeatureCollection} to a {@code FeatureSource}
195	* and sets this as the new data source for the table.
196	*
197	* @param fs
198	* the feature source
199	* @param amd
200	* {@link AttributeMetaData}-Map to define the visible attributes
201	* and translation
202	*/
203	public void setFeatureCollection(StyledFeaturesInterface layer,
204	Filter filter) {
205	this.layer = layer;
206	try {
207	if (layer == null)
208	setFeatureSource(null, null, null);
209	else {
210	FeatureCollection fc = layer.getFeatureCollection();
211	String fcName = fc.getSchema().getTypeName();
212	FeatureSource fs = new MemoryDataStore(fc)
213	.getFeatureSource(fcName);
214	setFeatureSource(fs, layer.getAttributeMetaDataMap(), filter);
215	}
216	} catch (Exception err) {
217	throw new RuntimeException(err);
218	}
219	}
220
221	/**
222	* Sets the {@code StyledFeatureCollection} as new data source for the
223	* table.
224	*
225	* @param fs
226	* the feature source
227	* @param amd
228	* {@link AttributeMetaData}-Map to define the visible attributes
229	* and translation
230	*/
231	public void setFeatureCollection(StyledFeatureSourceInterface layer,
232	Filter filter) {
233	this.layer = layer;
234	try {
235	if (layer == null)
236	setFeatureSource(null, null, null);
237	else
238	setFeatureSource(layer.getGeoObject(), layer
239	.getAttributeMetaDataMap(), filter);
240	} catch (Exception err) {
241	throw new RuntimeException(err);
242	}
243	}
244
245	/**
246	* Resets the filter for the table.
247	*
248	* @param filter
249	* a filter
250	*/
251	public void setFilter(Filter filter) {
252	try {
253	setFeatureSource(this.featureSource, this.origAMD, filter);
254	} catch (Exception err) {
255	LOGGER.error("Setting the filter of the table model", err);
256	throw new RuntimeException(err);
257	}
258	}
259
260	/**
261	* @return <code>Filter.INCLUDE</code> or the {@link Filter} applied to the
262	* Features
263	*/
264	public Filter getFilter() {
265	return this.filter;
266	}
267
268	/**
269	* After calling {@code super.reorganize(.)} this method replaced the column
270	* descriptions with the titles of the {@code AttributeMetaData}.
271	*
272	* @param fireTableStructureChanged
273	* indicates whether a table event is initiated after reorganize
274	*/
275	@Override
276	protected void reorganize(boolean fireTableStructureChanged) {
277	super.reorganize(false);
278	// translate the column names
279	if (visibleAMD != null) {
280	Iterator<Integer> keys = visibleAMD.keySet().iterator();
281	for (int i = 0; i < colNames.length && keys.hasNext(); i++) {
282	Translation title = visibleAMD.get(keys.next()).getTitle();
283	if (!I8NUtil.isEmpty(title)) {
284	// System.out.println("set colname " + i + " to " +
285	// title.toString());
286	colNames[i] = title.toString();
287	}
288	}
289	}
290	if (fireTableStructureChanged)
291	fireTableStructureChanged();
292	}
293
294	/**
295	* @return Cached bounds for the whole dataset (without applying the filter)
296	* or <code>null</code>
297	*/
298	public Envelope getBounds() {
299	return bounds;
300	}
301	}