/[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 52 by mojays, Fri Apr 17 13:57:14 2009 UTC revision 244 by alfonx, Wed Jul 29 09:33:33 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, focussing (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 java.util.Iterator;   * as published by the Free Software Foundation; either version 3
14  import java.util.Map;   * of the License, or (at your option) any later version.
15  import java.util.TreeMap;   *
16  import java.util.Vector;   * This program is distributed in the hope that it will be useful,
17     * but WITHOUT ANY WARRANTY; without even the implied warranty of
18  import org.geotools.data.DefaultQuery;   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19  import org.geotools.data.FeatureSource;   * GNU General Public License for more details.
20  import org.geotools.data.Query;   *
21  import org.geotools.data.memory.MemoryDataStore;   * You should have received a copy of the GNU Lesser General Public License (license.txt)
22  import org.geotools.feature.FeatureCollection;   * along with this program; if not, write to the Free Software
23  import org.opengis.filter.Filter;   * 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  import schmitzm.geotools.gui.FeatureCollectionTableModel;   *
26  import skrueger.AttributeMetaData;   * Contributors:
27     *     Martin O. J. Schmitz - initial API and implementation
28     *     Stefan A. Krüger - additional utility classes
29  /**   ******************************************************************************/
30   * This class extends the  package skrueger.geotools;
31   * @author <a href="mailto:[email protected]">Martin Schmitz</a> (University of Bonn/Germany)  
32   *  import java.util.Iterator;
33   */  import java.util.Map;
34  public class StyledFeatureCollectionTableModel extends FeatureCollectionTableModel {  import java.util.Vector;
35      
36    protected Map<Integer,AttributeMetaData> visibleAMD = null;  import org.apache.log4j.Logger;
37      import org.geotools.data.DefaultQuery;
38    public StyledFeatureCollectionTableModel(StyledFeatureCollectionInterface map) {  import org.geotools.data.FeatureSource;
39      super();  import org.geotools.data.Query;
40      setFeatureCollection(map);  import org.geotools.data.memory.MemoryDataStore;
41    }  import org.geotools.feature.AttributeType;
42      import org.geotools.feature.FeatureCollection;
43    public StyledFeatureCollectionTableModel(StyledFeatureSourceInterface map) {  import org.opengis.filter.Filter;
44      super();  
45      setFeatureCollection(map);  import schmitzm.geotools.gui.FeatureCollectionTableModel;
46    }  import skrueger.AttributeMetaData;
47      import skrueger.i8n.I8NUtil;
48    protected void setFeatureSource(FeatureSource fs, Map<Integer,AttributeMetaData> amd) throws Exception {  import skrueger.i8n.Translation;
49      FeatureCollection fc = null;  
50      this.visibleAMD      = new TreeMap<Integer, AttributeMetaData>();  import com.vividsolutions.jts.geom.Envelope;
51      if ( fs != null ) {  
52        Query query = new DefaultQuery();  /**
53        if ( amd != null ) {   * This class extends the the {@link FeatureCollectionTableModel} with the
54          // determine the names of the visible Attributes   * functionalities of the {@link AttributeMetaData} of
55          this.visibleAMD = StyledMapUtil.getVisibleAttributeMetaData(amd, true);   * {@linkplain StyledLayerInterface styled objects}.
56          Vector<String> visibleAttrNames = new Vector<String>();   * <ul>
57          for ( int attrIdx : visibleAMD.keySet() )   * <li>column names are translated according to
58            visibleAttrNames.add( fs.getSchema().getAttributeType(attrIdx).getLocalName() );   * {@link AttributeMetaData#getTitle()}</li>
59          // create a query for the visible attributes     * <li>columns are hidden according to {@link AttributeMetaData#isVisible()()}</li>
60          query = new DefaultQuery(   * </ul>
61                         fs.getSchema().getTypeName(),   *
62                         Filter.INCLUDE,   * @author <a href="mailto:[email protected]">Martin Schmitz</a>
63                         visibleAttrNames.toArray(new String[0])   *         (University of Bonn/Germany)
64          );   */
65        }  public class StyledFeatureCollectionTableModel extends
66        fc = fs.getFeatures(query);                  FeatureCollectionTableModel {
67      }          final static private Logger LOGGER = Logger
68      setFeatureCollection( fc );                          .getLogger(StyledFeatureCollectionTableModel.class);
69    }          /** Holds the data source as styled layer. */
70              protected StyledLayerInterface<?> layer = null;
71    public void setFeatureCollection(StyledFeatureCollectionInterface map) {          /** Contains only the visible elements of the {@link AttributeMetaData}-Map */
72      try {          protected Map<Integer, AttributeMetaData> visibleAMD = null;
73        if ( map == null )          /** Holds the data source for the table as {@code FeatureSource}. */
74          setFeatureSource(null,null);          protected FeatureSource featureSource = null;
75        else {          /** Contains the complete {@link AttributeMetaData}-Map of the styled layer. */
76          FeatureCollection fc     = map.getGeoObject();          protected Map<Integer, AttributeMetaData> origAMD = null;
77          String            fcName = fc.getFeatureType().getTypeName();          /** Holds the current filter on the table */
78          FeatureSource     fs     = new MemoryDataStore(fc).getFeatureSource(fcName);          protected Filter filter = null;
79          setFeatureSource(fs, map.getAttributeMetaDataMap());          /** Holds the Bounds for all features. Only set once during the constructor **/
80        }          protected Envelope bounds;
81      } catch (Exception err) {  
82        throw new RuntimeException(err);          
83      }  
84    }          /**
85               * Creates a new table model for a styled layer.
86    public void setFeatureCollection(StyledFeatureSourceInterface map) {           *
87      try {           * @param layer
88        if ( map == null )           *            the styled layer
89          setFeatureSource(null,null);           */
90        else          public StyledFeatureCollectionTableModel(
91          setFeatureSource(map.getGeoObject(), map.getAttributeMetaDataMap());                          StyledFeatureCollectionInterface layer) {
92      } catch (Exception err) {                  this(layer, Filter.INCLUDE);
93        throw new RuntimeException(err);          }
94      }  
95    }          /**
96               * Creates a new table model for a styled layer.
97    @Override           *
98    public void reorganize() {           * @param layer
99      super.reorganize();           *            the styled layer
100      // translate the column names           * @param filter
101      Iterator<Integer> keys = visibleAMD.keySet().iterator();           *            filter applied to the table
102      for (int i=0; keys.hasNext(); i++)           */
103        colNames[i] = visibleAMD.get( keys.next() ).getTitle().toString();          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.52  
changed lines
  Added in v.244
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26