/[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 145 by alfonx, Thu Jun 18 00:28:28 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 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 StyledMapInterface styled objects}.
37   * <ul>   * <ul>
38   * <li>column names are translated according to   *   <li>column names are translated according to {@link AttributeMetaData#getTitle()}</li>
39   * {@link AttributeMetaData#getTitle()}</li>   *   <li>columns are hidden according to {@link AttributeMetaData#isVisible()()}</li>
  * <li>columns are hidden according to {@link AttributeMetaData#isVisible()()}</li>  
40   * </ul>   * </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  public class StyledFeatureCollectionTableModel extends FeatureCollectionTableModel {
44                  FeatureCollectionTableModel {    final static private Logger LOGGER = Logger.getLogger(StyledFeatureCollectionTableModel.class);
45      /** Holds the data source as styled map. */
46          protected Map<Integer, AttributeMetaData> visibleAMD = null;    protected StyledMapInterface<?> map = null;
47      /** Contains only the visible elements of the {@link AttributeMetaData}-Map */
48          public StyledFeatureCollectionTableModel(    protected Map<Integer, AttributeMetaData> visibleAMD = null;
49                          StyledFeatureCollectionInterface map) {    /** Holds the data source for the table as {@code FeatureSource}. */
50                  super();    protected FeatureSource featureSource = null;
51                  setFeatureCollection(map);    /** 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          public StyledFeatureCollectionTableModel(StyledFeatureSourceInterface map) {    protected Filter filter = null;
55                  super();    /** Holds the Bounds for all features. Only set once during the constructor **/
56                  setFeatureCollection(map);    protected Envelope bounds;
57          }  
58      /**
59          protected void setFeatureSource(FeatureSource fs,     * Creates a new table model for a styled map.
60                          Map<Integer, AttributeMetaData> amd) throws Exception {     * @param map the styled map
61                  FeatureCollection fc = null;     */
62                  this.visibleAMD = null;    public StyledFeatureCollectionTableModel(StyledFeatureCollectionInterface map) {
63                  if (fs != null) {      this(map,Filter.INCLUDE);
64                          Query query = new DefaultQuery();    }
65                          if (amd != null) {  
66                                  // determine the names of the visible Attributes    /**
67                                  this.visibleAMD = StyledMapUtil.getVisibleAttributeMetaData(     * Creates a new table model for a styled map.
68                                                  amd, true);     * @param map the styled map
69                                  Vector<String> visibleAttrNames = new Vector<String>();     * @param filter filter applied to the table
70       */
71                                  // Add the column with the geometry (usually "the_geom")    public StyledFeatureCollectionTableModel(StyledFeatureCollectionInterface map, Filter filter) {
72                                  visibleAttrNames.add(fs.getSchema().getDefaultGeometry()      super();
73                                                  .getLocalName());      setFeatureCollection(map, filter);
74      }
75                                  for (int attrIdx : visibleAMD.keySet())  
76                                          visibleAttrNames.add(fs.getSchema().getAttributeType(    /**
77                                                          attrIdx).getLocalName());     * Creates a new table model for a styled map.
78       * @param map the styled map
79                                  // create a query for the visible attributes     */
80                                  String[] properties = visibleAttrNames.toArray(new String[0]);    public StyledFeatureCollectionTableModel(StyledFeatureSourceInterface map) {
81        this(map,Filter.INCLUDE);
82                                  query = new DefaultQuery(fs.getSchema().getTypeName(),    }
83                                                  Filter.INCLUDE, properties);  
84                          }    /**
85                          fc = fs.getFeatures(query);     * Creates a new table model for a styled map.
86                  }     * @param map the styled map
87                  setFeatureCollection(fc);     * @param filter filter applied to the table
88          }     */
89      public StyledFeatureCollectionTableModel(StyledFeatureSourceInterface map, Filter filter) {
90          public void setFeatureCollection(StyledFeatureCollectionInterface map) {      super();
91                  try {      setFeatureCollection(map, filter);
92                          if (map == null)    }
93                                  setFeatureSource(null, null);  
94                          else {    /**
95                                  FeatureCollection fc = map.getGeoObject();     * Sets a new data source for the table.
96                                  String fcName = fc.getFeatureType().getTypeName();     * @param fs     the feature source
97                                  FeatureSource fs = new MemoryDataStore(fc)     * @param amd    {@link AttributeMetaData}-Map to define the visible attributes
98                                                  .getFeatureSource(fcName);     *               and translation
99                                  setFeatureSource(fs, map.getAttributeMetaDataMap());     */
100                          }    protected void setFeatureSource(FeatureSource fs, Map<Integer, AttributeMetaData> amd, Filter filter) throws Exception {
101                  } catch (Exception err) {      if ( filter == null )
102                          throw new RuntimeException(err);        filter = Filter.INCLUDE;
103                  }      
104          }      this.featureSource = fs;
105        this.filter        = filter;
106          public void setFeatureCollection(StyledFeatureSourceInterface map) {      this.origAMD       = amd;
107                  try {      this.visibleAMD    = null;
108                          if (map == null)      
109                                  setFeatureSource(null, null);      FeatureCollection fc = null;
110                          else      if (fs != null) {
111                                  setFeatureSource(map.getGeoObject(), map          
112                                                  .getAttributeMetaDataMap());         bounds = fs.getBounds();
113                  } catch (Exception err) {          
114                          throw new RuntimeException(err);        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          @Override          Vector<String> visibleAttrNames = new Vector<String>();
119          public void reorganize() {          // Add the column with the geometry (usually "the_geom")
120                  super.reorganize();          visibleAttrNames.add(fs.getSchema().getDefaultGeometry().getLocalName());
121                  // translate the column names          for (int attrIdx : visibleAMD.keySet())
122                  if (visibleAMD != null) {            visibleAttrNames.add(fs.getSchema().getAttributeType(attrIdx).getLocalName());
123                          Iterator<Integer> keys = visibleAMD.keySet().iterator();  
124                          for (int i = 0; i < colNames.length && keys.hasNext(); i++) {          // create a query for the visible attributes
125                                  Translation title = visibleAMD.get(keys.next()).getTitle();          String[] properties = visibleAttrNames.toArray(new String[0]);
126                                  if (!I8NUtil.isEmpty(title)) {          
127                                          System.out.println("set colname " + i + " to "          LOGGER.debug("Query contains the following attributes: " + visibleAttrNames);
128                                                          + title.toString());          
129                                          colNames[i] = title.toString();          query = new DefaultQuery(fs.getSchema().getTypeName(), filter, properties);
130                                  }        }
131                          }        fc = fs.getFeatures(query);
132                  }  
133                  fireTableStructureChanged();  // 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      /**
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) {
197            LOGGER.error("Setting the filter of the table model", err);
198          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
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             * @return 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.56  
changed lines
  Added in v.145
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26