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