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