/[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 47 by mojays, Fri Apr 17 12:28:50 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;
15    import java.util.Map;
16    import java.util.Vector;
17    
18    import org.apache.log4j.Logger;
19    import org.geotools.data.DefaultQuery;
20    import org.geotools.data.FeatureSource;
21    import org.geotools.data.Query;
22    import org.geotools.data.memory.MemoryDataStore;
23    import org.geotools.feature.FeatureCollection;
24    import org.opengis.filter.Filter;
25    
26  import schmitzm.geotools.gui.FeatureCollectionTableModel;  import schmitzm.geotools.gui.FeatureCollectionTableModel;
27    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 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)
42     */
43  public class StyledFeatureCollectionTableModel extends FeatureCollectionTableModel {  public class StyledFeatureCollectionTableModel extends FeatureCollectionTableModel {
44        final static private Logger LOGGER = Logger.getLogger(StyledFeatureCollectionTableModel.class);
45      /** 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      super(null);      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();
73        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      super(null);      this(map,Filter.INCLUDE);
82    }    }
83    
84    public String[] createColumnNames() {    /**
85      return new String[0];     * 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();
91        setFeatureCollection(map, filter);
92      }
93    
94      /**
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;
110        if (fs != null) {
111            
112           bounds = fs.getBounds();
113            
114          Query query = new DefaultQuery(fs.getSchema().getTypeName(), filter);
115          if (amd != null) {
116            // determine the names of the visible Attributes
117            this.visibleAMD = StyledMapUtil.getVisibleAttributeMetaData(amd, true);
118            Vector<String> visibleAttrNames = new Vector<String>();
119            // Add the column with the geometry (usually "the_geom")
120            visibleAttrNames.add(fs.getSchema().getDefaultGeometry().getLocalName());
121            for (int attrIdx : visibleAMD.keySet())
122              visibleAttrNames.add(fs.getSchema().getAttributeType(attrIdx).getLocalName());
123    
124            // create a query for the visible attributes
125            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);
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);
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       * @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 {
158          if (map == null)
159            setFeatureSource(null, null, null);
160          else {
161            FeatureCollection fc = map.getGeoObject();
162            String fcName = fc.getSchema().getTypeName();
163            FeatureSource fs = new MemoryDataStore(fc).getFeatureSource(fcName);
164            setFeatureSource(fs, map.getAttributeMetaDataMap(), filter);
165          }
166        } catch (Exception err) {
167          throw new RuntimeException(err);
168        }
169      }
170    
171      /**
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 {
180          if (map == null)
181            setFeatureSource(null, null, null);
182          else
183            setFeatureSource(map.getGeoObject(), map.getAttributeMetaDataMap(), filter);
184        } catch (Exception err) {
185          throw new RuntimeException(err);
186        }
187    }    }
188        
189    public int getRowCount() {    /**
190      return 0;     * 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) {
197            LOGGER.error("Setting the filter of the table model", err);
198          throw new RuntimeException(err);
199        }
200    }    }
201        
202    public Object getValueAt(int row, int col) {    /**
203      return "";     * @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
216      protected void reorganize(boolean fireTableStructureChanged) {
217        super.reorganize(false);
218        // translate the column names
219        if (visibleAMD != null) {
220          Iterator<Integer> keys = visibleAMD.keySet().iterator();
221          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.47  
changed lines
  Added in v.127
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26