/[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

trunk/src/skrueger/geotools/StyledFeatureCollectionTableModel.java revision 47 by mojays, Fri Apr 17 12:28:50 2009 UTC branches/1.0-gt2-2.6/src/skrueger/geotools/StyledFeatureCollectionTableModel.java revision 315 by mojays, Wed Aug 26 11:03:27 2009 UTC
# Line 1  Line 1 
1  /** SCHMITZM - This file is part of the java library of Martin O.J. Schmitz (SCHMITZM)  /*******************************************************************************
2     * Copyright (c) 2009 Martin O. J. Schmitz.
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.   * This file is part of the SCHMITZM library - a collection of utility
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   * classes based on Java 1.6, focusing (not only) on Java Swing
6     * and the Geotools library.
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.   * The SCHMITZM project is hosted at:
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.   * http://wald.intevation.org/projects/schmitzm/
10   **/   *
11  package skrueger.geotools;   * This program is free software; you can redistribute it and/or
12     * modify it under the terms of the GNU Lesser General Public License
13  import schmitzm.geotools.gui.FeatureCollectionTableModel;   * as published by the Free Software Foundation; either version 3
14     * of the License, or (at your option) any later version.
15  public class StyledFeatureCollectionTableModel extends FeatureCollectionTableModel {   *
16       * This program is distributed in the hope that it will be useful,
17    public StyledFeatureCollectionTableModel(StyledFeatureCollectionInterface map) {   * but WITHOUT ANY WARRANTY; without even the implied warranty of
18      super(null);   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19    }   * GNU General Public License for more details.
20       *
21    public StyledFeatureCollectionTableModel(StyledFeatureSourceInterface map) {   * You should have received a copy of the GNU Lesser General Public License (license.txt)
22      super(null);   * along with this program; if not, write to the Free Software
23    }   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
24     * or try this link: http://www.gnu.org/licenses/lgpl.html
25    public String[] createColumnNames() {   *
26      return new String[0];   * Contributors:
27    }   *     Martin O. J. Schmitz - initial API and implementation
28       *     Stefan A. Krüger - additional utility classes
29    public int getRowCount() {   ******************************************************************************/
30      return 0;  package skrueger.geotools;
31    }  
32      import java.util.Iterator;
33    public Object getValueAt(int row, int col) {  import java.util.Map;
34      return "";  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.47  
changed lines
  Added in v.315
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26