/[schmitzm]/trunk/src/skrueger/geotools/StyledFeatureCollectionTableModel.java
ViewVC logotype

Diff of /trunk/src/skrueger/geotools/StyledFeatureCollectionTableModel.java

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 46 by mojays, Fri Apr 17 11:44:05 2009 UTC revision 244 by alfonx, Wed Jul 29 09:33:33 2009 UTC
# Line 1  Line 1 
1  package skrueger.geotools;  /*******************************************************************************
2     * Copyright (c) 2009 Martin O. J. Schmitz.
3  import schmitzm.geotools.gui.FeatureCollectionTableModel;   *
4     * This file is part of the SCHMITZM library - a collection of utility
5  public class StyledFeatureCollectionTableModel extends FeatureCollectionTableModel {   * classes based on Java 1.6, focussing (not only) on Java Swing
6       * and the Geotools library.
7    public StyledFeatureCollectionTableModel(StyledFeatureCollectionInterface map) {   *
8      super(null);   * The SCHMITZM project is hosted at:
9    }   * http://wald.intevation.org/projects/schmitzm/
10       *
11    public StyledFeatureCollectionTableModel(StyledFeatureSourceInterface map) {   * This program is free software; you can redistribute it and/or
12      super(null);   * modify it under the terms of the GNU Lesser General Public License
13    }   * as published by the Free Software Foundation; either version 3
14     * of the License, or (at your option) any later version.
15    public String[] createColumnNames() {   *
16      return new String[0];   * This program is distributed in the hope that it will be useful,
17    }   * but WITHOUT ANY WARRANTY; without even the implied warranty of
18       * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19    public int getRowCount() {   * GNU General Public License for more details.
20      return 0;   *
21    }   * You should have received a copy of the GNU Lesser General Public License (license.txt)
22       * along with this program; if not, write to the Free Software
23    public Object getValueAt(int row, int col) {   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
24      return "";   * or try this link: http://www.gnu.org/licenses/lgpl.html
25    }   *
26  }   * Contributors:
27     *     Martin O. J. Schmitz - initial API and implementation
28     *     Stefan A. Krüger - additional utility classes
29     ******************************************************************************/
30    package skrueger.geotools;
31    
32    import java.util.Iterator;
33    import java.util.Map;
34    import java.util.Vector;
35    
36    import org.apache.log4j.Logger;
37    import org.geotools.data.DefaultQuery;
38    import org.geotools.data.FeatureSource;
39    import org.geotools.data.Query;
40    import org.geotools.data.memory.MemoryDataStore;
41    import org.geotools.feature.AttributeType;
42    import org.geotools.feature.FeatureCollection;
43    import org.opengis.filter.Filter;
44    
45    import schmitzm.geotools.gui.FeatureCollectionTableModel;
46    import skrueger.AttributeMetaData;
47    import skrueger.i8n.I8NUtil;
48    import skrueger.i8n.Translation;
49    
50    import com.vividsolutions.jts.geom.Envelope;
51    
52    /**
53     * This class extends the the {@link FeatureCollectionTableModel} with the
54     * functionalities of the {@link AttributeMetaData} of
55     * {@linkplain StyledLayerInterface styled objects}.
56     * <ul>
57     * <li>column names are translated according to
58     * {@link AttributeMetaData#getTitle()}</li>
59     * <li>columns are hidden according to {@link AttributeMetaData#isVisible()()}</li>
60     * </ul>
61     *
62     * @author <a href="mailto:[email protected]">Martin Schmitz</a>
63     *         (University of Bonn/Germany)
64     */
65    public class StyledFeatureCollectionTableModel extends
66                    FeatureCollectionTableModel {
67            final static private Logger LOGGER = Logger
68                            .getLogger(StyledFeatureCollectionTableModel.class);
69            /** Holds the data source as styled layer. */
70            protected StyledLayerInterface<?> layer = null;
71            /** Contains only the visible elements of the {@link AttributeMetaData}-Map */
72            protected Map<Integer, AttributeMetaData> visibleAMD = null;
73            /** Holds the data source for the table as {@code FeatureSource}. */
74            protected FeatureSource featureSource = null;
75            /** Contains the complete {@link AttributeMetaData}-Map of the styled layer. */
76            protected Map<Integer, AttributeMetaData> origAMD = null;
77            /** Holds the current filter on the table */
78            protected Filter filter = null;
79            /** Holds the Bounds for all features. Only set once during the constructor **/
80            protected Envelope bounds;
81    
82            
83    
84            /**
85             * Creates a new table model for a styled layer.
86             *
87             * @param layer
88             *            the styled layer
89             */
90            public StyledFeatureCollectionTableModel(
91                            StyledFeatureCollectionInterface layer) {
92                    this(layer, Filter.INCLUDE);
93            }
94    
95            /**
96             * Creates a new table model for a styled layer.
97             *
98             * @param layer
99             *            the styled layer
100             * @param filter
101             *            filter applied to the table
102             */
103            public StyledFeatureCollectionTableModel(
104                            StyledFeatureCollectionInterface layer, Filter filter) {
105                    super();
106                    setFeatureCollection(layer, filter);
107            }
108    
109    
110            /**
111             * Creates a new table model for a styled layer.
112             *
113             * @param layer
114             *            the styled layer
115             */
116            public StyledFeatureCollectionTableModel(StyledFeaturesInterface layer) {
117                    this(layer, Filter.INCLUDE);
118            }
119    
120            /**
121             * Creates a new table model for a styled layer.
122             *
123             * @param layer
124             *            the styled layer
125             * @param filter
126             *            filter applied to the table
127             */
128            public StyledFeatureCollectionTableModel(StyledFeaturesInterface layer,
129                            Filter filter) {
130                    super();
131                    setFeatureCollection(layer, filter);
132            }
133    
134            /**
135             * Sets a new data source for the table.
136             *
137             * @param fs
138             *            the feature source
139             * @param amd
140             *            {@link AttributeMetaData}-Map to define the visible attributes
141             *            and translation
142             */
143            protected void setFeatureSource(FeatureSource fs,
144                            Map<Integer, AttributeMetaData> amd, Filter filter)
145                            throws Exception {
146                    if (filter == null)
147                            filter = Filter.INCLUDE;
148    
149                    this.featureSource = fs;
150                    this.filter = filter;
151                    this.origAMD = amd;
152                    this.visibleAMD = null;
153    
154                    FeatureCollection fc = null;
155                    if (fs != null) {
156    
157                            bounds = fs.getBounds();
158    
159                            Query query = new DefaultQuery(fs.getSchema().getTypeName(), filter);
160                            if (amd != null) {
161                                    // determine the names of the visible Attributes
162                                    this.visibleAMD = StyledLayerUtil.getVisibleAttributeMetaData(
163                                                    amd, true);
164                                    Vector<String> visibleAttrNames = new Vector<String>();
165                                    // Add the column with the geometry (usually "the_geom")
166                                    visibleAttrNames.add(fs.getSchema().getDefaultGeometry()
167                                                    .getLocalName());
168                                    for (int attrIdx : visibleAMD.keySet()) {
169    
170                                            /**
171                                             * If the user removed columns from the schema of the DBF
172                                             * file, there might exist AttributeMetaData for columns
173                                             * that don't exists. We check here to avoid an
174                                             * ArrayOutOfIndex.
175                                             */
176                                            if (attrIdx < fs.getSchema().getAttributeCount()) {
177                                                    final AttributeType attributeTypeAtIdx = fs.getSchema()
178                                                                    .getAttributeType(attrIdx);
179                                                    visibleAttrNames.add(attributeTypeAtIdx.getLocalName());
180                                            } else {
181                                                    LOGGER.warn("AttributeMetaData has been found for columnIdx="+attrIdx+", but fs.getSchema().getAttributeCount() = "+fs.getSchema().getAttributeCount()+". Ignored.");
182                                            }
183                                    }
184    
185                                    // create a query for the visible attributes
186                                    String[] properties = visibleAttrNames.toArray(new String[0]);
187    
188                                    LOGGER.debug("Query contains the following attributes: "
189                                                    + visibleAttrNames);
190    
191                                    query = new DefaultQuery(fs.getSchema().getTypeName(), filter,
192                                                    properties);
193                            }
194                            fc = fs.getFeatures(query);
195    
196                            // FAILS:!!!, even with query = new
197                            // DefaultQuery(fs.getSchema().getTypeName(), filter);
198                            // java.lang.UnsupportedOperationException: Unknown feature
199                            // attribute: PQM_MOD
200                            // at
201                            // schmitzm.geotools.feature.FeatureOperationTree.evaluate(FeatureOperationTree.java:93)
202                            // bounds = fc.getBounds();
203                            // SK, 17.4.2009
204                            //      
205                            // System.out.println("Filter = "+filter);
206                            // System.out.println("Size of FC = "+fc.size());
207                            // System.out.println("anz att= "+fc.getNumberOfAttributes());
208                    }
209                    setFeatureCollection(fc);
210            }
211    
212            /**
213             * Converts the {@code StyledFeatureCollection} to a {@code FeatureSource}
214             * and sets this as the new data source for the table.
215             *
216             * @param fs
217             *            the feature source
218             * @param amd
219             *            {@link AttributeMetaData}-Map to define the visible attributes
220             *            and translation
221             */
222            public void setFeatureCollection(StyledFeaturesInterface layer,
223                            Filter filter) {
224                    this.layer = layer;
225                    try {
226                            if (layer == null)
227                                    setFeatureSource(null, null, null);
228                            else {
229                                    FeatureCollection fc = layer.getFeatureCollection();
230                                    String fcName = fc.getSchema().getTypeName();
231                                    FeatureSource fs = new MemoryDataStore(fc)
232                                                    .getFeatureSource(fcName);
233                                    setFeatureSource(fs, layer.getAttributeMetaDataMap(), filter);
234                            }
235                    } catch (Exception err) {
236                            throw new RuntimeException(err);
237                    }
238            }
239    
240            /**
241             * Sets the {@code StyledFeatureCollection} as new data source for the
242             * table.
243             *
244             * @param fs
245             *            the feature source
246             * @param amd
247             *            {@link AttributeMetaData}-Map to define the visible attributes
248             *            and translation
249             */
250            public void setFeatureCollection(StyledFeatureSourceInterface layer,
251                            Filter filter) {
252                    this.layer = layer;
253                    try {
254                            if (layer == null)
255                                    setFeatureSource(null, null, null);
256                            else
257                                    setFeatureSource(layer.getGeoObject(), layer
258                                                    .getAttributeMetaDataMap(), filter);
259                    } catch (Exception err) {
260                            throw new RuntimeException(err);
261                    }
262            }
263    
264            /**
265             * Resets the filter for the table.
266             *
267             * @param filter
268             *            a filter
269             */
270            public void setFilter(Filter filter) {
271                    try {
272                            setFeatureSource(this.featureSource, this.origAMD, filter);
273                    } catch (Exception err) {
274                            LOGGER.error("Setting the filter of the table model", err);
275                            throw new RuntimeException(err);
276                    }
277            }
278    
279            /**
280             * @return <code>Filter.INCLUDE</code> or the {@link Filter} applied to the
281             *         Features
282             */
283            public Filter getFilter() {
284                    return this.filter;
285            }
286    
287            /**
288             * After calling {@code super.reorganize(.)} this method replaced the column
289             * descriptions with the titles of the {@code AttributeMetaData}.
290             *
291             * @param fireTableStructureChanged
292             *            indicates whether a table event is initiated after reorganize
293             */
294            @Override
295            protected void reorganize(boolean fireTableStructureChanged) {
296                    super.reorganize(false);
297                    // translate the column names
298                    if (visibleAMD != null) {
299                            Iterator<Integer> keys = visibleAMD.keySet().iterator();
300                            for (int i = 0; i < colNames.length && keys.hasNext(); i++) {
301                                    Translation title = visibleAMD.get(keys.next()).getTitle();
302                                    if (!I8NUtil.isEmpty(title)) {
303                                            // System.out.println("set colname " + i + " to " +
304                                            // title.toString());
305                                            colNames[i] = title.toString();
306                                    }
307                            }
308                    }
309                    if (fireTableStructureChanged)
310                            fireTableStructureChanged();
311            }
312    
313            /**
314             * @return Cached bounds for the whole dataset (without applying the filter)
315             *         or <code>null</code>
316             */
317            public Envelope getBounds() {
318                    return bounds;
319            }
320    }
Legend:
Removed from v.46  
changed lines
  Added in v.244
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26