/[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

trunk/src/skrueger/geotools/StyledFeatureCollectionTableModel.java revision 112 by mojays, Wed May 13 09:18:53 2009 UTC branches/1.0-gt2-2.6/src/skrueger/geotools/StyledFeatureCollectionTableModel.java revision 490 by alfonx, Fri Oct 23 12:35:59 2009 UTC
# Line 1  Line 1 
1  /** SCHMITZM - This file is part of the java library of Martin O.J. Schmitz (SCHMITZM)  /*******************************************************************************
2     * Copyright (c) 2009 Martin O. J. Schmitz.
3      This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version.   *
4      This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.   * This file is part of the SCHMITZM library - a collection of utility
5      You should have received a copy of the GNU Lesser General Public License along with this library; if not, write to the Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110, USA   * classes based on Java 1.6, focusing (not only) on Java Swing
6     * and the Geotools library.
7      Diese Bibliothek ist freie Software; Sie dürfen sie unter den Bedingungen der GNU Lesser General Public License, wie von der Free Software Foundation veröffentlicht, weiterverteilen und/oder modifizieren; entweder gemäß Version 2.1 der Lizenz oder (nach Ihrer Option) jeder späteren Version.   *
8      Diese Bibliothek wird in der Hoffnung weiterverbreitet, daß sie nützlich sein wird, jedoch OHNE IRGENDEINE GARANTIE, auch ohne die implizierte Garantie der MARKTREIFE oder der VERWENDBARKEIT FÜR EINEN BESTIMMTEN ZWECK. Mehr Details finden Sie in der GNU Lesser General Public License.   * The SCHMITZM project is hosted at:
9      Sie sollten eine Kopie der GNU Lesser General Public License zusammen mit dieser Bibliothek erhalten haben; falls nicht, schreiben Sie an die Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110, USA.   * http://wald.intevation.org/projects/schmitzm/
10   **/   *
11  package skrueger.geotools;   * This program is free software; you can redistribute it and/or
12     * modify it under the terms of the GNU Lesser General Public License
13     * as published by the Free Software Foundation; either version 3
14  import java.util.Iterator;   * of the License, or (at your option) any later version.
15  import java.util.Map;   *
16  import java.util.TreeMap;   * This program is distributed in the hope that it will be useful,
17  import java.util.Vector;   * but WITHOUT ANY WARRANTY; without even the implied warranty of
18     * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19  import org.apache.log4j.Logger;   * GNU General Public License for more details.
20  import org.geotools.data.DefaultQuery;   *
21  import org.geotools.data.FeatureSource;   * You should have received a copy of the GNU Lesser General Public License (license.txt)
22  import org.geotools.data.Query;   * along with this program; if not, write to the Free Software
23  import org.geotools.data.memory.MemoryDataStore;   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
24  import org.geotools.feature.FeatureCollection;   * or try this link: http://www.gnu.org/licenses/lgpl.html
25  import org.opengis.filter.Filter;   *
26     * Contributors:
27  import com.vividsolutions.jts.geom.Envelope;   *     Martin O. J. Schmitz - initial API and implementation
28     *     Stefan A. Krüger - additional utility classes
29  import schmitzm.geotools.gui.FeatureCollectionTableModel;   ******************************************************************************/
30  import skrueger.AttributeMetaData;  package skrueger.geotools;
31  import skrueger.i8n.I8NUtil;  
32  import skrueger.i8n.Translation;  import java.util.Vector;
33    
34  /**  import org.apache.log4j.Logger;
35   * This class extends the the {@link FeatureCollectionTableModel} with the  import org.geotools.data.DefaultQuery;
36   * functionalities of the {@link AttributeMetaData} of  import org.geotools.data.FeatureSource;
37   * {@linkplain StyledMapInterface styled objects}.  import org.geotools.data.Query;
38   * <ul>  import org.geotools.feature.FeatureCollection;
39   *   <li>column names are translated according to {@link AttributeMetaData#getTitle()}</li>  import org.opengis.feature.simple.SimpleFeature;
40   *   <li>columns are hidden according to {@link AttributeMetaData#isVisible()()}</li>  import org.opengis.feature.simple.SimpleFeatureType;
41   * </ul>  import org.opengis.feature.type.AttributeDescriptor;
42   * @author <a href="mailto:[email protected]">Martin Schmitz</a> (University of Bonn/Germany)  import org.opengis.filter.Filter;
43   */  
44  public class StyledFeatureCollectionTableModel extends FeatureCollectionTableModel {  import schmitzm.geotools.gui.FeatureCollectionTableModel;
45    final static private Logger LOGGER = Logger.getLogger(StyledFeatureCollectionTableModel.class);  import skrueger.AttributeMetadata;
46    /** Holds the data source as styled map. */  
47    protected StyledMapInterface<?> map = null;  import com.vividsolutions.jts.geom.Envelope;
48    /** Contains only the visible elements of the {@link AttributeMetaData}-Map */  
49    protected Map<Integer, AttributeMetaData> visibleAMD = null;  /**
50    /** Holds the data source for the table as {@code FeatureSource}. */   * This class extends the the {@link FeatureCollectionTableModel} with the
51    protected FeatureSource featureSource = null;   * functionalities of the {@link AttributeMetadata}.
52    /** Contains the complete {@link AttributeMetaData}-Map of the styled layer. */   * <ul>
53    protected Map<Integer, AttributeMetaData> origAMD = null;   * <li>column names are translated according to
54    /** Holds the current filter on the table */   * {@link AttributeMetadata#getTitle()}</li>
55    protected Filter filter = null;   * <li>columns are hidden according to {@link AttributeMetaData#isVisible()()}</li>
56    /** Holds the Bounds for all features. Only set once during the constructor **/   * <li>Any filter defined in the {@link StyledFeaturesInterface} will be applied.</li>
57    protected Envelope bounds;   * </ul>
58     *
59    /**   * @author Stefan A. Krüger
60     * Creates a new table model for a styled map.   */
61     * @param map the styled map  public class StyledFeatureCollectionTableModel extends
62     */                  FeatureCollectionTableModel {
63    public StyledFeatureCollectionTableModel(StyledFeatureCollectionInterface map) {          final static private Logger LOGGER = Logger
64      this(map,Filter.INCLUDE);                          .getLogger(StyledFeatureCollectionTableModel.class);
65    }          /** Contains the complete {@link AttributeMetadata}-Map of the styled layer. */
66            protected AttributeMetadataMap origAMD = null;
67    /**          /** Holds the current filter on the table */
68     * Creates a new table model for a styled map.          protected Filter filter = null;
69     * @param map the styled map          /** Holds the Bounds for all features. Only set once during the constructor **/
70     * @param filter filter applied to the table          protected Envelope bounds;
71     */  
72    public StyledFeatureCollectionTableModel(StyledFeatureCollectionInterface map, Filter filter) {          
73      super();          /**
74      setFeatureCollection(map, filter);           * Creates a new table model for a styled layer.
75    }           *
76             * @param styledFeatures
77    /**           *            the styled layer
78     * Creates a new table model for a styled map.           * @param filter
79     * @param map the styled map           *            filter applied to the table
80     */           */
81    public StyledFeatureCollectionTableModel(StyledFeatureSourceInterface map) {          public StyledFeatureCollectionTableModel(StyledFeaturesInterface<?> styledFeatures) {
82      this(map,Filter.INCLUDE);                  setStyledFeatures(styledFeatures);
83    }          }
84    
85    /**          /**
86     * Creates a new table model for a styled map.           * Sets a new data source for the table.
87     * @param map the styled map           *
88     * @param filter filter applied to the table           * @param fs
89     */           *            the feature source
90    public StyledFeatureCollectionTableModel(StyledFeatureSourceInterface map, Filter filter) {           * @param amd
91      super();           *            {@link AttributeMetadata}-Map to define the visible attributes
92      setFeatureCollection(map, filter);           *            and translation
93    }           */
94            protected void setFeatureSource(FeatureSource<SimpleFeatureType, SimpleFeature> fs,
95    /**                          AttributeMetadataMap amd, Filter filter)
96     * Sets a new data source for the table.                          throws Exception {
97     * @param fs     the feature source                  
98     * @param amd    {@link AttributeMetaData}-Map to define the visible attributes                  if (filter == null)
99     *               and translation                          filter = Filter.INCLUDE;
100     */  
101    protected void setFeatureSource(FeatureSource fs, Map<Integer, AttributeMetaData> amd, Filter filter) throws Exception {  //              this.featureSource = fs;
102      if ( filter == null )                  this.filter = filter;
103        filter = Filter.INCLUDE;                  this.origAMD = amd;
104        
105      this.featureSource = fs;                  FeatureCollection<SimpleFeatureType, SimpleFeature> fc = null;
106      this.filter        = filter;                  if (fs != null) {
107      this.origAMD       = amd;  
108      this.visibleAMD    = null;                          bounds = fs.getBounds();
109        
110      FeatureCollection fc = null;                          final SimpleFeatureType schema = fs.getSchema();
111      if (fs != null) {                          Query query = new DefaultQuery(schema.getTypeName(), filter);
112                                    if (amd != null) {
113         bounds = fs.getBounds();                                  Vector<String> visibleAttrNames = new Vector<String>();
114                                            // Add the column with the geometry (usually "the_geom")
115        Query query = new DefaultQuery(fs.getSchema().getTypeName(), filter);                                  
116        if (amd != null) {                                  for (AttributeDescriptor aDesc : schema.getAttributeDescriptors()) {
117          // determine the names of the visible Attributes                                          
118          this.visibleAMD = StyledMapUtil.getVisibleAttributeMetaData(amd, true);                                          // Always add the geometry
119          Vector<String> visibleAttrNames = new Vector<String>();                                          if (schema.getGeometryDescriptor()
120          // Add the column with the geometry (usually "the_geom")                                                  .getName().equals(aDesc.getName())) {
121          visibleAttrNames.add(fs.getSchema().getDefaultGeometry().getLocalName());                                                  visibleAttrNames.add(schema.getGeometryDescriptor()
122          for (int attrIdx : visibleAMD.keySet())                                                                  .getLocalName());
123            visibleAttrNames.add(fs.getSchema().getAttributeType(attrIdx).getLocalName());                                                  continue;
124                                            }
125          // create a query for the visible attributes                                          
126          String[] properties = visibleAttrNames.toArray(new String[0]);                                          if (amd.get(aDesc.getName()).isVisible())
127                                                            visibleAttrNames.add(aDesc.getName().getLocalPart());
128          LOGGER.debug("Query contains the following attributes: " + visibleAttrNames);                                  }
129            
130          query = new DefaultQuery(fs.getSchema().getTypeName(), filter, properties);                                  // create a query for the visible attributes
131        }                                  String[] properties = visibleAttrNames.toArray(new String[] {});
132        fc = fs.getFeatures(query);  
133                                    LOGGER.debug("Query contains the following attributes: "
134  // FAILS:!!!, even with  query = new DefaultQuery(fs.getSchema().getTypeName(), filter);                                                  + visibleAttrNames);
135                          // java.lang.UnsupportedOperationException: Unknown feature  
136                          // attribute: PQM_MOD  
137                          // at                                  /**
138                          // schmitzm.geotools.feature.FeatureOperationTree.evaluate(FeatureOperationTree.java:93)                                   * I got NPEs when properties contained only [the_geom] ?!??!!??
139                          // bounds = fc.getBounds();                                   */
140                          // SK, 17.4.2009                                  if (properties.length > 1) {
141                          //                                                query = new DefaultQuery(schema.getTypeName(), filter,
142                          // System.out.println("Filter = "+filter);                                                          properties);
143                          // System.out.println("Size of FC = "+fc.size());                                  } else {
144                          // System.out.println("anz att= "+fc.getNumberOfAttributes());                                          query = new DefaultQuery(schema.getTypeName(), filter);
145      }                                  }
146      setFeatureCollection(fc);                          }
147    }                          fc = fs.getFeatures(query);
148                    }
149    /**                  setFeatureCollection(fc);
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           * Converts the {@code StyledFeatureCollection} to a {@code FeatureSource}
154     *               and translation           * and sets this as the new data source for the table.
155     */           *
156    public void setFeatureCollection(StyledFeatureCollectionInterface map, Filter filter) {           * @param fs
157      this.map = map;           *            the feature source
158      try {           * @param amd
159        if (map == null)           *            {@link AttributeMetadata}-Map to define the visible attributes
160          setFeatureSource(null, null, null);           *            and translation
161        else {           */
162          FeatureCollection fc = map.getGeoObject();          public void setStyledFeatures(StyledFeaturesInterface<?> styledFeatures) {
163          String fcName = fc.getSchema().getTypeName();                  try {
164          FeatureSource fs = new MemoryDataStore(fc).getFeatureSource(fcName);                          if (styledFeatures == null)
165          setFeatureSource(fs, map.getAttributeMetaDataMap(), filter);                                  setFeatureSource(null, null, null);
166        }                          else {
167      } catch (Exception err) {                                  setFeatureSource(styledFeatures.getFeatureSource(), styledFeatures.getAttributeMetaDataMap(), styledFeatures.getFilter());
168        throw new RuntimeException(err);                          }
169      }                  } catch (Exception err) {
170    }                          throw new RuntimeException(err);
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           * After calling {@code super.reorganize(.)} this method replaced the column
176     *               and translation           * descriptions with the titles of the {@code AttributeMetaData}.
177     */           *
178    public void setFeatureCollection(StyledFeatureSourceInterface map, Filter filter) {           * @param fireTableStructureChanged
179      this.map = map;           *            indicates whether a table event is initiated after reorganize
180      try {           */
181        if (map == null)          @Override
182          setFeatureSource(null, null, null);          protected void reorganize(boolean fireTableStructureChanged) {
183        else                  
184          setFeatureSource(map.getGeoObject(), map.getAttributeMetaDataMap(), filter);                  super.reorganize(false);
185      } catch (Exception err) {                  
186        throw new RuntimeException(err);                  // translate the column names
187      }                  if (origAMD != null) {
188    }                          for (int i = 0; i < colNames.length; i++) {
189                                      colNames[i] = origAMD.get(colNames[i]).getTitle().toString();
190    /**                          }
191     * Resets the filter for the table.                          
192     * @param filter a filter                  }
193     */                  if (fireTableStructureChanged)
194    public void setFilter(Filter filter) {                          fireTableStructureChanged();
195      try{          }
196        setFeatureSource(this.featureSource, this.origAMD, filter);  
197      } catch (Exception err) {          /**
198          LOGGER.error("Setting the filter of the table model", err);           * @return Cached bounds for the whole dataset (without applying the filter)
199        throw new RuntimeException(err);           *         or <code>null</code>
200      }           */
201    }          public Envelope getBounds() {
202                      return bounds;
203    /**          }
204     * @return <code>Filter.INCLUDE</code> or the {@link Filter} applied to the Features  }
    */  
   public Filter getFilter() {  
           return this.filter;  
   }  
   
   /**  
    * After calling {@code super.reorganize(.)} this method replaced the  
    * column descriptions with the titles of the {@code AttributeMetaData}.  
    * @param fireTableStructureChanged indicates whether a table event is  
    *        initiated after reorganize  
    */  
   @Override  
   protected void reorganize(boolean fireTableStructureChanged) {  
     super.reorganize(false);  
     // translate the column names  
     if (visibleAMD != null) {  
       Iterator<Integer> keys = visibleAMD.keySet().iterator();  
       for (int i = 0; i < colNames.length && keys.hasNext(); i++) {  
         Translation title = visibleAMD.get(keys.next()).getTitle();  
         if (!I8NUtil.isEmpty(title)) {  
 //          System.out.println("set colname " + i + " to " + title.toString());  
           colNames[i] = title.toString();  
         }  
       }  
     }  
     if ( fireTableStructureChanged )  
       fireTableStructureChanged();  
   }  
   
   /**  
          * @returns Cached bounds for the whole dataset (without applying the  
          *          filter) or <code>null</code>  
          */  
         public Envelope getBounds() {  
                 return bounds;  
         }  
 }  

Legend:
Removed from v.112  
changed lines
  Added in v.490

[email protected]
ViewVC Help
Powered by ViewVC 1.1.26