/[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 46 by mojays, Fri Apr 17 11:44:05 2009 UTC branches/2.0-RC1/src/skrueger/geotools/StyledFeatureCollectionTableModel.java revision 607 by alfonx, Wed Dec 9 15:13:42 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, focusing (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.HashMap;
33    import java.util.Vector;
34    
35    import org.apache.log4j.Logger;
36    import org.geotools.data.DefaultQuery;
37    import org.geotools.data.FeatureSource;
38    import org.geotools.data.Query;
39    import org.geotools.feature.FeatureCollection;
40    import org.opengis.feature.simple.SimpleFeature;
41    import org.opengis.feature.simple.SimpleFeatureType;
42    import org.opengis.feature.type.AttributeDescriptor;
43    import org.opengis.filter.Filter;
44    
45    import schmitzm.geotools.feature.FeatureUtil;
46    import schmitzm.geotools.gui.FeatureCollectionTableModel;
47    import skrueger.AttributeMetadata;
48    
49    import com.vividsolutions.jts.geom.Envelope;
50    
51    /**
52     * This class extends the the {@link FeatureCollectionTableModel} with the
53     * functionalities of the {@link AttributeMetadata}.
54     * <ul>
55     * <li>column names are translated according to
56     * {@link AttributeMetadata#getTitle()}</li>
57     * <li>columns are hidden according to {@link AttributeMetaData#isVisible()()}</li>
58     * <li>Any filter defined in the {@link StyledFeaturesInterface} will be
59     * applied.</li>
60     * </ul>
61     *
62     * @author Stefan A. Krüger
63     */
64    public class StyledFeatureCollectionTableModel extends
65                    FeatureCollectionTableModel {
66            final static private Logger LOGGER = Logger
67                            .getLogger(StyledFeatureCollectionTableModel.class);
68            /** Contains the complete {@link AttributeMetadata}-Map of the styled layer. */
69            protected AttributeMetadataMap amdMap = null;
70            /** Holds the current filter on the table */
71            protected Filter filter = null;
72            /** Holds the Bounds for all features. Only set once during the constructor **/
73            protected Envelope bounds;
74            /**
75             * Tooltips für die Spaltennamen. Wird nur beim Aufruf von
76             * {@link #reorganize} befuellt.
77             */
78            protected String[] colTooltips = null;
79    
80            /**
81             * Creates a new table model for a styled layer.
82             *
83             * @param styledFeatures
84             *            the styled layer
85             * @param filter
86             *            filter applied to the table
87             */
88            public StyledFeatureCollectionTableModel(
89                            StyledFeaturesInterface<?> styledFeatures) {
90                    setStyledFeatures(styledFeatures);
91            }
92    
93            /**
94             * Sets a new data source for the table.
95             *
96             * @param fs
97             *            the feature source
98             * @param amdm
99             *            {@link AttributeMetadata}-Map to define the visible attributes
100             *            and translation
101             */
102            protected void setFeatureSource(
103                            FeatureSource<SimpleFeatureType, SimpleFeature> fs,
104                            AttributeMetadataMap amdm, Filter filter) throws Exception {
105    
106                    if (filter == null)
107                            filter = Filter.INCLUDE;
108    
109                    // this.featureSource = fs;
110                    this.filter = filter;
111                    this.amdMap = amdm;
112    
113                    FeatureCollection<SimpleFeatureType, SimpleFeature> fc = null;
114                    if (fs != null) {
115    
116                            bounds = fs.getBounds();
117    
118                            final SimpleFeatureType schema = fs.getSchema();
119                            Query query = new DefaultQuery(schema.getTypeName(), filter);
120                            if (amdm != null) {
121                                    Vector<String> visibleAttrNames = new Vector<String>();
122    
123                                    // Add the column with the geometry (usually "the_geom") always
124                                    visibleAttrNames.add(schema.getGeometryDescriptor()
125                                                    .getLocalName());
126    
127                                    // Add other visible attributes as ordered by weights
128                                    for (AttributeMetadata a : amdm.sortedValuesVisibleOnly()) {
129                                            visibleAttrNames.add(a.getLocalName());
130                                    }
131    
132    //                      Tested with 2.6.x trunk from 2009-11-26 and it now works. So we only request the properties we need!                    
133    //                              /**
134    //                               * I got NPEs when properties contained only [the_geom] ?!??!!??
135    //                               */
136    //                              if (properties.length > 1) {
137                                            query = new DefaultQuery(schema.getTypeName(), filter,
138                                                            visibleAttrNames.toArray(new String[] {}));
139    //                              } else {
140    //                                      query = new DefaultQuery(schema.getTypeName(), filter);
141    //                              }
142                            }
143                            fc = fs.getFeatures(query);
144                    }
145                    setFeatureCollection(fc);
146            }
147    
148            /**
149             * Converts the {@code StyledFeatureCollection} to a {@code FeatureSource}
150             * and sets this as the new data source for the table.
151             *
152             * @param fs
153             *            the feature source
154             * @param amd
155             *            {@link AttributeMetadata}-Map to define the visible attributes
156             *            and translation
157             */
158            public void setStyledFeatures(StyledFeaturesInterface<?> styledFeatures) {
159                    try {
160                            if (styledFeatures == null)
161                                    setFeatureSource(null, null, null);
162                            else {
163                                    setFeatureSource(styledFeatures.getFeatureSource(),
164                                                    styledFeatures.getAttributeMetaDataMap(),
165                                                    styledFeatures.getFilter());
166                            }
167                    } catch (Exception err) {
168                            throw new RuntimeException(err);
169                    }
170            }
171    
172            /**
173             * After calling {@code super.reorganize(.)} this method replaced the column
174             * descriptions with the titles of the {@code AttributeMetaData}.
175             *
176             * @param fireTableStructureChanged
177             *            indicates whether a table event is initiated after reorganize
178             */
179            @Override
180            protected void reorganize(boolean fireTableStructureChanged) {
181    
182                    featureArray = FeatureUtil.featuresToArray(featureTable);
183                    if (featureArray == null || featureArray.length == 0) {
184                            colNames = new String[0];
185                            colTooltips = new String[0]; // Only set and used in
186                                                                                            // StyledFeatureCollectionTableModel
187                            colClass = new Class[0];
188                    } else {
189                            // Struktur der Tabelle vom AttributeMetaDtaaMap übernehmen
190                            SimpleFeatureType schema = featureArray[0].getFeatureType();
191                            // Pruefen, welche Attribute angezeigt werden
192                            attrTypes.clear();
193                            for (AttributeMetadata amd : amdMap.sortedValuesVisibleOnly()) {
194                                    AttributeDescriptor type = schema.getDescriptor(amd.getName());
195                                    if (attrFilter == null || attrFilter.accept(type))
196                                            attrTypes.add(type);
197                            }
198                            // Namen und Attribut-Indizes der angezeigten Spalten ermitteln
199                            colNames = new String[attrTypes.size()];
200                            colTooltips = new String[attrTypes.size()]; // Only set and used in
201                                                                                                                    // StyledFeatureCollectionTableModel
202                            colClass = new Class[attrTypes.size()];
203                            attrIdxForCol = new int[attrTypes.size()];
204                            for (int i = 0; i < colNames.length; i++) {
205                                    AttributeDescriptor descriptor = schema.getDescriptor(amdMap.sortedValuesVisibleOnly().get(i).getName());
206    
207                                    // Not so nice in 26: find the index of an attribute...
208                                    int idx = schema.getAttributeDescriptors().indexOf(descriptor);
209                                    attrIdxForCol[i] = idx;
210    
211                                    String attName = schema.getAttributeDescriptors().get(idx)
212                                                    .getLocalName();
213                                    colNames[i] = amdMap.get(attName).getTitle().toString();
214                                    AttributeMetadata amd = amdMap.get(attName);
215                                    colTooltips[i] = "<html>"+amd.getDesc().toString()+"<br>"+amd.getName()+"</html>";
216                                    colClass[i] = schema.getAttributeDescriptors().get(idx).getType()
217                                                    .getBinding();
218                            }
219                    }
220    
221                    // store feature indexes in HashMap to optimize findFeature(.)
222                    featureIdx = new HashMap<String, Integer>();
223                    for (int i = 0; i < featureArray.length; i++)
224                            if (featureArray[i] != null)
225                                    featureIdx.put(featureArray[i].getID(), i);
226    //
227    //              // translate the column names
228    //              if (amdMap != null) {
229    //                      for (int i = 0; i < colNames.length; i++) {
230    //                              colTooltips[i] = amdMap.get(colNames[i]).getDesc().toString()
231    //                                              + "<br>" + colNames[i];
232    //                              colNames[i] = amdMap.get(colNames[i]).getTitle().toString();
233    //
234    //                      }
235    //              }
236                    if (fireTableStructureChanged)
237                            fireTableStructureChanged();
238    
239            }
240    
241            /**
242             * @return Cached bounds for the whole dataset (without applying the filter)
243             *         or <code>null</code>
244             */
245            public Envelope getBounds() {
246                    return bounds;
247            }
248    }
Legend:
Removed from v.46  
changed lines
  Added in v.607
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26