/[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 56 by alfonx, Fri Apr 17 15:19:00 2009 UTC revision 224 by alfonx, Tue Jul 14 15:57:19 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   * <li>column names are translated according to
39   * {@link AttributeMetaData#getTitle()}</li>   * {@link AttributeMetaData#getTitle()}</li>
# Line 39  import skrueger.i8n.Translation; Line 42  import skrueger.i8n.Translation;
42   *   *
43   * @author <a href="mailto:[email protected]">Martin Schmitz</a>   * @author <a href="mailto:[email protected]">Martin Schmitz</a>
44   *         (University of Bonn/Germany)   *         (University of Bonn/Germany)
  *  
45   */   */
46  public class StyledFeatureCollectionTableModel extends  public class StyledFeatureCollectionTableModel extends
47                  FeatureCollectionTableModel {                  FeatureCollectionTableModel {
48            final static private Logger LOGGER = Logger
49                            .getLogger(StyledFeatureCollectionTableModel.class);
50            /** Holds the data source as styled map. */
51            protected StyledLayerInterface<?> layer = null;
52            /** Contains only the visible elements of the {@link AttributeMetaData}-Map */
53          protected Map<Integer, AttributeMetaData> visibleAMD = null;          protected Map<Integer, AttributeMetaData> visibleAMD = null;
54            /** 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            protected Map<Integer, AttributeMetaData> origAMD = null;
58            /** Holds the current filter on the table */
59            protected Filter filter = null;
60            /** Holds the Bounds for all features. Only set once during the constructor **/
61            protected Envelope bounds;
62    
63            
64    
65            /**
66             * Creates a new table model for a styled map.
67             *
68             * @param layer
69             *            the styled layer
70             */
71            public StyledFeatureCollectionTableModel(
72                            StyledFeatureCollectionInterface layer) {
73                    this(layer, Filter.INCLUDE);
74            }
75    
76            /**
77             * Creates a new table model for a styled map.
78             *
79             * @param layer
80             *            the styled layer
81             * @param filter
82             *            filter applied to the table
83             */
84          public StyledFeatureCollectionTableModel(          public StyledFeatureCollectionTableModel(
85                          StyledFeatureCollectionInterface map) {                          StyledFeatureCollectionInterface layer, Filter filter) {
86                  super();                  super();
87                  setFeatureCollection(map);                  setFeatureCollection(layer, filter);
88            }
89    
90    
91            /**
92             * Creates a new table model for a styled map.
93             *
94             * @param layer
95             *            the styled layer
96             */
97            public StyledFeatureCollectionTableModel(StyledFeaturesInterface layer) {
98                    this(layer, Filter.INCLUDE);
99          }          }
100    
101          public StyledFeatureCollectionTableModel(StyledFeatureSourceInterface map) {          /**
102             * Creates a new table model for a styled map.
103             *
104             * @param layer
105             *            the styled layer
106             * @param filter
107             *            filter applied to the table
108             */
109            public StyledFeatureCollectionTableModel(StyledFeaturesInterface layer,
110                            Filter filter) {
111                  super();                  super();
112                  setFeatureCollection(map);                  setFeatureCollection(layer, filter);
113          }          }
114    
115            /**
116             * Sets a new data source for the table.
117             *
118             * @param fs
119             *            the feature source
120             * @param amd
121             *            {@link AttributeMetaData}-Map to define the visible attributes
122             *            and translation
123             */
124          protected void setFeatureSource(FeatureSource fs,          protected void setFeatureSource(FeatureSource fs,
125                          Map<Integer, AttributeMetaData> amd) throws Exception {                          Map<Integer, AttributeMetaData> amd, Filter filter)
126                  FeatureCollection fc = null;                          throws Exception {
127                    if (filter == null)
128                            filter = Filter.INCLUDE;
129    
130                    this.featureSource = fs;
131                    this.filter = filter;
132                    this.origAMD = amd;
133                  this.visibleAMD = null;                  this.visibleAMD = null;
134    
135                    FeatureCollection fc = null;
136                  if (fs != null) {                  if (fs != null) {
137                          Query query = new DefaultQuery();  
138                            bounds = fs.getBounds();
139    
140                            Query query = new DefaultQuery(fs.getSchema().getTypeName(), filter);
141                          if (amd != null) {                          if (amd != null) {
142                                  // determine the names of the visible Attributes                                  // determine the names of the visible Attributes
143                                  this.visibleAMD = StyledMapUtil.getVisibleAttributeMetaData(                                  this.visibleAMD = StyledLayerUtil.getVisibleAttributeMetaData(
144                                                  amd, true);                                                  amd, true);
145                                  Vector<String> visibleAttrNames = new Vector<String>();                                  Vector<String> visibleAttrNames = new Vector<String>();
   
146                                  // Add the column with the geometry (usually "the_geom")                                  // Add the column with the geometry (usually "the_geom")
147                                  visibleAttrNames.add(fs.getSchema().getDefaultGeometry()                                  visibleAttrNames.add(fs.getSchema().getDefaultGeometry()
148                                                  .getLocalName());                                                  .getLocalName());
149                                    for (int attrIdx : visibleAMD.keySet()) {
150    
151                                  for (int attrIdx : visibleAMD.keySet())                                          /**
152                                          visibleAttrNames.add(fs.getSchema().getAttributeType(                                           * If the user removed columns from the schema of the DBF
153                                                          attrIdx).getLocalName());                                           * file, there might exist AttributeMetaData for columns
154                                             * that don't exists. We check here to avoid an
155                                             * ArrayOutOfIndex.
156                                             */
157                                            if (attrIdx < fs.getSchema().getAttributeCount()) {
158                                                    final AttributeType attributeTypeAtIdx = fs.getSchema()
159                                                                    .getAttributeType(attrIdx);
160                                                    visibleAttrNames.add(attributeTypeAtIdx.getLocalName());
161                                            } else {
162                                                    LOGGER.warn("AttributeMetaData has been found for columnIdx="+attrIdx+", but fs.getSchema().getAttributeCount() = "+fs.getSchema().getAttributeCount()+". Ignored.");
163                                            }
164                                    }
165    
166                                  // create a query for the visible attributes                                  // create a query for the visible attributes
167                                  String[] properties = visibleAttrNames.toArray(new String[0]);                                  String[] properties = visibleAttrNames.toArray(new String[0]);
168    
169                                  query = new DefaultQuery(fs.getSchema().getTypeName(),                                  LOGGER.debug("Query contains the following attributes: "
170                                                  Filter.INCLUDE, properties);                                                  + visibleAttrNames);
171    
172                                    query = new DefaultQuery(fs.getSchema().getTypeName(), filter,
173                                                    properties);
174                          }                          }
175                          fc = fs.getFeatures(query);                          fc = fs.getFeatures(query);
176    
177                            // FAILS:!!!, even with query = new
178                            // DefaultQuery(fs.getSchema().getTypeName(), filter);
179                            // java.lang.UnsupportedOperationException: Unknown feature
180                            // attribute: PQM_MOD
181                            // at
182                            // schmitzm.geotools.feature.FeatureOperationTree.evaluate(FeatureOperationTree.java:93)
183                            // bounds = fc.getBounds();
184                            // SK, 17.4.2009
185                            //      
186                            // System.out.println("Filter = "+filter);
187                            // System.out.println("Size of FC = "+fc.size());
188                            // System.out.println("anz att= "+fc.getNumberOfAttributes());
189                  }                  }
190                  setFeatureCollection(fc);                  setFeatureCollection(fc);
191          }          }
192    
193          public void setFeatureCollection(StyledFeatureCollectionInterface map) {          /**
194             * Converts the {@code StyledFeatureCollection} to a {@code FeatureSource}
195             * and sets this as the new data source for the table.
196             *
197             * @param fs
198             *            the feature source
199             * @param amd
200             *            {@link AttributeMetaData}-Map to define the visible attributes
201             *            and translation
202             */
203            public void setFeatureCollection(StyledFeaturesInterface layer,
204                            Filter filter) {
205                    this.layer = layer;
206                  try {                  try {
207                          if (map == null)                          if (layer == null)
208                                  setFeatureSource(null, null);                                  setFeatureSource(null, null, null);
209                          else {                          else {
210                                  FeatureCollection fc = map.getGeoObject();                                  FeatureCollection fc = layer.getFeatureCollection();
211                                  String fcName = fc.getFeatureType().getTypeName();                                  String fcName = fc.getSchema().getTypeName();
212                                  FeatureSource fs = new MemoryDataStore(fc)                                  FeatureSource fs = new MemoryDataStore(fc)
213                                                  .getFeatureSource(fcName);                                                  .getFeatureSource(fcName);
214                                  setFeatureSource(fs, map.getAttributeMetaDataMap());                                  setFeatureSource(fs, layer.getAttributeMetaDataMap(), filter);
215                          }                          }
216                  } catch (Exception err) {                  } catch (Exception err) {
217                          throw new RuntimeException(err);                          throw new RuntimeException(err);
218                  }                  }
219          }          }
220    
221          public void setFeatureCollection(StyledFeatureSourceInterface map) {          /**
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 {                  try {
235                          if (map == null)                          if (layer == null)
236                                  setFeatureSource(null, null);                                  setFeatureSource(null, null, null);
237                          else                          else
238                                  setFeatureSource(map.getGeoObject(), map                                  setFeatureSource(layer.getGeoObject(), layer
239                                                  .getAttributeMetaDataMap());                                                  .getAttributeMetaDataMap(), filter);
240                  } catch (Exception err) {                  } catch (Exception err) {
241                          throw new RuntimeException(err);                          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          @Override
276          public void reorganize() {          protected void reorganize(boolean fireTableStructureChanged) {
277                  super.reorganize();                  super.reorganize(false);
278                  // translate the column names                  // translate the column names
279                  if (visibleAMD != null) {                  if (visibleAMD != null) {
280                          Iterator<Integer> keys = visibleAMD.keySet().iterator();                          Iterator<Integer> keys = visibleAMD.keySet().iterator();
281                          for (int i = 0; i < colNames.length && keys.hasNext(); i++) {                          for (int i = 0; i < colNames.length && keys.hasNext(); i++) {
282                                  Translation title = visibleAMD.get(keys.next()).getTitle();                                  Translation title = visibleAMD.get(keys.next()).getTitle();
283                                  if (!I8NUtil.isEmpty(title)) {                                  if (!I8NUtil.isEmpty(title)) {
284                                          System.out.println("set colname " + i + " to "                                          // System.out.println("set colname " + i + " to " +
285                                                          + title.toString());                                          // title.toString());
286                                          colNames[i] = title.toString();                                          colNames[i] = title.toString();
287                                  }                                  }
288                          }                          }
289                  }                  }
290                  fireTableStructureChanged();                  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.56  
changed lines
  Added in v.224
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26