/[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 58 by mojays, Fri Apr 17 15:55:33 2009 UTC revision 225 by alfonx, Wed Jul 15 08:05:22 2009 UTC
# Line 12  package skrueger.geotools; Line 12  package skrueger.geotools;
12    
13  import java.util.Iterator;  import java.util.Iterator;
14  import java.util.Map;  import java.util.Map;
 import java.util.TreeMap;  
15  import java.util.Vector;  import java.util.Vector;
16    
17    import org.apache.log4j.Logger;
18  import org.geotools.data.DefaultQuery;  import org.geotools.data.DefaultQuery;
19  import org.geotools.data.FeatureSource;  import org.geotools.data.FeatureSource;
20  import org.geotools.data.Query;  import org.geotools.data.Query;
21  import org.geotools.data.memory.MemoryDataStore;  import org.geotools.data.memory.MemoryDataStore;
22    import org.geotools.feature.AttributeType;
23  import org.geotools.feature.FeatureCollection;  import org.geotools.feature.FeatureCollection;
24  import org.opengis.filter.Filter;  import org.opengis.filter.Filter;
25    
# Line 27  import skrueger.AttributeMetaData; Line 28  import skrueger.AttributeMetaData;
28  import skrueger.i8n.I8NUtil;  import skrueger.i8n.I8NUtil;
29  import skrueger.i8n.Translation;  import skrueger.i8n.Translation;
30    
31    import com.vividsolutions.jts.geom.Envelope;
32    
33  /**  /**
34   * This class extends the the {@link FeatureCollectionTableModel} with the   * This class extends the the {@link FeatureCollectionTableModel} with the
35   * functionalities of the {@link AttributeMetaData} of   * functionalities of the {@link AttributeMetaData} of
36   * {@linkplain StyledMapInterface styled objects}.   * {@linkplain StyledLayerInterface styled objects}.
37   * <ul>   * <ul>
38   *   <li>column names are translated according to {@link AttributeMetaData#getTitle()}</li>   * <li>column names are translated according to
39   *   <li>columns are hidden according to {@link AttributeMetaData#isVisible()()}</li>   * {@link AttributeMetaData#getTitle()}</li>
40     * <li>columns are hidden according to {@link AttributeMetaData#isVisible()()}</li>
41   * </ul>   * </ul>
42   * @author <a href="mailto:[email protected]">Martin Schmitz</a> (University of Bonn/Germany)   *
43     * @author <a href="mailto:[email protected]">Martin Schmitz</a>
44     *         (University of Bonn/Germany)
45   */   */
46  public class StyledFeatureCollectionTableModel extends FeatureCollectionTableModel {  public class StyledFeatureCollectionTableModel extends
47    /** Holds the data source as styled map. */                  FeatureCollectionTableModel {
48    protected StyledMapInterface map = null;          final static private Logger LOGGER = Logger
49    /** Contains only the visible elements of the {@link AttributeMetaData}-Map */                          .getLogger(StyledFeatureCollectionTableModel.class);
50    protected Map<Integer, AttributeMetaData> visibleAMD = null;          /** Holds the data source as styled layer. */
51    /** Holds the data source for the table as {@code FeatureSource}. */          protected StyledLayerInterface<?> layer = null;
52    protected FeatureSource featureSource = null;          /** Contains only the visible elements of the {@link AttributeMetaData}-Map */
53    /** Holds the current filter on the table */          protected Map<Integer, AttributeMetaData> visibleAMD = null;
54    protected Filter filter = null;          /** 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     * Creates a new table model for a styled map.          protected Map<Integer, AttributeMetaData> origAMD = null;
58     * @param map the styled map          /** Holds the current filter on the table */
59     */          protected Filter filter = null;
60    public StyledFeatureCollectionTableModel(StyledFeatureCollectionInterface map) {          /** Holds the Bounds for all features. Only set once during the constructor **/
61      this(map,Filter.INCLUDE);          protected Envelope bounds;
62    }  
63            
64    /**  
65     * Creates a new table model for a styled map.          /**
66     * @param map the styled map           * Creates a new table model for a styled layer.
67     * @param filter filter applied to the table           *
68     */           * @param layer
69    public StyledFeatureCollectionTableModel(StyledFeatureCollectionInterface map, Filter filter) {           *            the styled layer
70      super();           */
71      setFeatureCollection(map, filter);          public StyledFeatureCollectionTableModel(
72    }                          StyledFeatureCollectionInterface layer) {
73                    this(layer, Filter.INCLUDE);
74    /**          }
75     * Creates a new table model for a styled map.  
76     * @param map the styled map          /**
77     */           * Creates a new table model for a styled layer.
78    public StyledFeatureCollectionTableModel(StyledFeatureSourceInterface map) {           *
79      this(map,Filter.INCLUDE);           * @param layer
80    }           *            the styled layer
81             * @param filter
82    /**           *            filter applied to the table
83     * Creates a new table model for a styled map.           */
84     * @param map the styled map          public StyledFeatureCollectionTableModel(
85     * @param filter filter applied to the table                          StyledFeatureCollectionInterface layer, Filter filter) {
86     */                  super();
87    public StyledFeatureCollectionTableModel(StyledFeatureSourceInterface map, Filter filter) {                  setFeatureCollection(layer, filter);
88      super();          }
89      setFeatureCollection(map, filter);  
90    }  
91            /**
92    /**           * Creates a new table model for a styled layer.
93     * Sets a new data source for the table.           *
94     * @param fs     the feature source           * @param layer
95     * @param amd    {@link AttributeMetaData}-Map to define the visible attributes           *            the styled layer
96     *               and translation           */
97     */          public StyledFeatureCollectionTableModel(StyledFeaturesInterface layer) {
98    protected void setFeatureSource(FeatureSource fs, Map<Integer, AttributeMetaData> amd, Filter filter) throws Exception {                  this(layer, Filter.INCLUDE);
99      if ( filter == null )          }
100        filter = Filter.INCLUDE;  
101            /**
102      this.featureSource = fs;           * Creates a new table model for a styled layer.
103      this.filter        = filter;           *
104      this.visibleAMD    = null;           * @param layer
105                 *            the styled layer
106      FeatureCollection fc = null;           * @param filter
107      if (fs != null) {           *            filter applied to the table
108        Query query = new DefaultQuery();           */
109        if (amd != null) {          public StyledFeatureCollectionTableModel(StyledFeaturesInterface layer,
110          // determine the names of the visible Attributes                          Filter filter) {
111          this.visibleAMD = StyledMapUtil.getVisibleAttributeMetaData(amd, true);                  super();
112          Vector<String> visibleAttrNames = new Vector<String>();                  setFeatureCollection(layer, filter);
113          // Add the column with the geometry (usually "the_geom")          }
114          visibleAttrNames.add(fs.getSchema().getDefaultGeometry().getLocalName());  
115          for (int attrIdx : visibleAMD.keySet())          /**
116            visibleAttrNames.add(fs.getSchema().getAttributeType(attrIdx).getLocalName());           * Sets a new data source for the table.
117             *
118          // create a query for the visible attributes           * @param fs
119          String[] properties = visibleAttrNames.toArray(new String[0]);           *            the feature source
120          query = new DefaultQuery(fs.getSchema().getTypeName(), filter, properties);           * @param amd
121        }           *            {@link AttributeMetaData}-Map to define the visible attributes
122        fc = fs.getFeatures(query);           *            and translation
123      }           */
124      setFeatureCollection(fc);          protected void setFeatureSource(FeatureSource fs,
125    }                          Map<Integer, AttributeMetaData> amd, Filter filter)
126                            throws Exception {
127    /**                  if (filter == null)
128     * Converts the {@code StyledFeatureCollection} to a {@code FeatureSource}                          filter = Filter.INCLUDE;
129     * and sets this as the new data source for the table.  
130     * @param fs     the feature source                  this.featureSource = fs;
131     * @param amd    {@link AttributeMetaData}-Map to define the visible attributes                  this.filter = filter;
132     *               and translation                  this.origAMD = amd;
133     */                  this.visibleAMD = null;
134    public void setFeatureCollection(StyledFeatureCollectionInterface map, Filter filter) {  
135      this.map = map;                  FeatureCollection fc = null;
136      try {                  if (fs != null) {
137        if (map == null)  
138          setFeatureSource(null, null, null);                          bounds = fs.getBounds();
139        else {  
140          FeatureCollection fc = map.getGeoObject();                          Query query = new DefaultQuery(fs.getSchema().getTypeName(), filter);
141          String fcName = fc.getFeatureType().getTypeName();                          if (amd != null) {
142          FeatureSource fs = new MemoryDataStore(fc).getFeatureSource(fcName);                                  // determine the names of the visible Attributes
143          setFeatureSource(fs, map.getAttributeMetaDataMap(), filter);                                  this.visibleAMD = StyledLayerUtil.getVisibleAttributeMetaData(
144        }                                                  amd, true);
145      } catch (Exception err) {                                  Vector<String> visibleAttrNames = new Vector<String>();
146        throw new RuntimeException(err);                                  // 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     * Sets the {@code StyledFeatureCollection} as new data source for the table.                                          /**
152     * @param fs     the feature source                                           * If the user removed columns from the schema of the DBF
153     * @param amd    {@link AttributeMetaData}-Map to define the visible attributes                                           * file, there might exist AttributeMetaData for columns
154     *               and translation                                           * that don't exists. We check here to avoid an
155     */                                           * ArrayOutOfIndex.
156    public void setFeatureCollection(StyledFeatureSourceInterface map, Filter filter) {                                           */
157      this.map = map;                                          if (attrIdx < fs.getSchema().getAttributeCount()) {
158      try {                                                  final AttributeType attributeTypeAtIdx = fs.getSchema()
159        if (map == null)                                                                  .getAttributeType(attrIdx);
160          setFeatureSource(null, null, null);                                                  visibleAttrNames.add(attributeTypeAtIdx.getLocalName());
161        else                                          } else {
162          setFeatureSource(map.getGeoObject(), map.getAttributeMetaDataMap(), filter);                                                  LOGGER.warn("AttributeMetaData has been found for columnIdx="+attrIdx+", but fs.getSchema().getAttributeCount() = "+fs.getSchema().getAttributeCount()+". Ignored.");
163      } catch (Exception err) {                                          }
164        throw new RuntimeException(err);                                  }
165      }  
166    }                                  // create a query for the visible attributes
167                                      String[] properties = visibleAttrNames.toArray(new String[0]);
168    /**  
169     * Resets the filter for the table.                                  LOGGER.debug("Query contains the following attributes: "
170     * @param filter a filter                                                  + visibleAttrNames);
171     */  
172    public void setFilter(Filter filter) {                                  query = new DefaultQuery(fs.getSchema().getTypeName(), filter,
173      try{                                                  properties);
174        setFeatureSource(this.featureSource, this.visibleAMD, filter);                          }
175      } catch (Exception err) {                          fc = fs.getFeatures(query);
176        throw new RuntimeException(err);  
177      }                          // FAILS:!!!, even with query = new
178    }                          // DefaultQuery(fs.getSchema().getTypeName(), filter);
179                            // java.lang.UnsupportedOperationException: Unknown feature
180    /**                          // attribute: PQM_MOD
181     * After calling {@code super.reorganize(.)} this method replaced the                          // at
182     * column descriptions with the titles of the {@code AttributeMetaData}.                          // schmitzm.geotools.feature.FeatureOperationTree.evaluate(FeatureOperationTree.java:93)
183     * @param fireTableStructureChanged indicates whether a table event is                          // bounds = fc.getBounds();
184     *        initiated after reorganize                          // SK, 17.4.2009
185     */                          //      
186    @Override                          // System.out.println("Filter = "+filter);
187    protected void reorganize(boolean fireTableStructureChanged) {                          // System.out.println("Size of FC = "+fc.size());
188      super.reorganize(false);                          // System.out.println("anz att= "+fc.getNumberOfAttributes());
189      // translate the column names                  }
190      if (visibleAMD != null) {                  setFeatureCollection(fc);
191        Iterator<Integer> keys = visibleAMD.keySet().iterator();          }
192        for (int i = 0; i < colNames.length && keys.hasNext(); i++) {  
193          Translation title = visibleAMD.get(keys.next()).getTitle();          /**
194          if (!I8NUtil.isEmpty(title)) {           * Converts the {@code StyledFeatureCollection} to a {@code FeatureSource}
195            System.out.println("set colname " + i + " to " + title.toString());           * and sets this as the new data source for the table.
196            colNames[i] = title.toString();           *
197          }           * @param fs
198        }           *            the feature source
199      }           * @param amd
200      if ( fireTableStructureChanged )           *            {@link AttributeMetaData}-Map to define the visible attributes
201        fireTableStructureChanged();           *            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  }  }
Legend:
Removed from v.58  
changed lines
  Added in v.225
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26