/ - Diff - Application: gvSIG desktop - gvSIG

Revision 23787

     /* gvSIG. Geographic Information System of the Valencian Government
+     *
      * Copyright (C) 2007-2008 Infrastructures and Transports Department
      * of the Valencian Gobernment (CIT)
+     *
      * This program is free software; you can redistribute it and/or
      * modify it under the terms of the GNU General Public License
      * as published by the Free Software Foundation; either version 2
      * of the License, or (at your option) any later version.
+     *
      * This program 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 General Public License for more details.
+     *
      * You should have received a copy of the GNU General Public License
      * along with this program; if not, write to the Free Software
      * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
      * MA  02110-1301, USA.
+     *
      */
     /*
      * AUTHORS (In addition to CIT):
      * 2008 {DiSiD Technologies}  {{Task}}
      */
     package org.gvsig.fmap.data.feature.swing.table;
     import org.gvsig.fmap.data.DataException;
     import org.gvsig.fmap.data.ReadException;
     import org.gvsig.fmap.data.feature.*;
     import org.gvsig.fmap.data.feature.paging.FeatureCollectionPagingHelper;
     /**
      * Extends the FeatureCollectionTableModel to add edition capabilities.
+     *
      * TODO: the current implementation does not work, update to the last API
      * changes for Feature edition.
+     *
      * @author <a href="mailto:cordin@disid.com">C?sar Ordi?ana</a>
      */
     public class EditableFeatureCollectionTableModel extends
             FeatureCollectionTableModel {
         /**
          * Serial Version UID
          */
         private static final long serialVersionUID = -8486424379657039107L;
         private FeatureQuery featureQuery;
         /**
          * @see FeatureCollectionTableModel#FeatureCollectionTableModel(FeatureStore,
          *      FeatureQuery, int)
          */
         public EditableFeatureCollectionTableModel(FeatureStore featureStore,
                 FeatureQuery featureQuery, int pageSize) throws ReadException {
             super(featureStore, featureQuery, pageSize);
+        }
         /**
          * @see FeatureCollectionTableModel#FeatureCollectionTableModel(FeatureStore,
          *      FeatureQuery)
          */
         public EditableFeatureCollectionTableModel(FeatureStore featureStore,
                 FeatureQuery featureQuery) throws ReadException {
             super(featureStore, featureQuery);
+        }
         /**
          * @see FeatureCollectionTableModel#FeatureCollectionTableModel(FeatureCollectionPagingHelper)
          */
         public EditableFeatureCollectionTableModel(
                 FeatureCollectionPagingHelper helper) {
             super(helper);
+        }
         @Override
         public boolean isCellEditable(int rowIndex, int columnIndex) {
             return getFeatureStore().isEditing();
+        }
         @Override
         public void setValueAt(Object value, int rowIndex, int columnIndex) {
             // Get the feature at rowIndex
             Feature feature = getHelper().getFeatureAt(rowIndex);
             // Only set the value if the feature exists
             if (feature != null) {
                 // We only need to update if the value to set is not equal to the
                 // current value
                 Object currentValue = feature.get(columnIndex);
                 if (value != currentValue
                         || (value != null && !value.equals(currentValue))) {
                     try {
                         // getFeatureStore().startEditing();
                         //
                         // EditableFeature editable = feature.getEditableFeature();
                         // editable.set(columnIndex, value);
                         //
                         // getFeatureStore().update(editable);
                         // getFeatureStore().finishEditing();
                         getFeatureStore().startEditing();
                         feature.editing();
                         feature.set(columnIndex, value);
                         getFeatureStore().update(feature);
                         // getHelper().reload();
                         // TODO: REVISAR
                         getHelper().setFeatureCollection(
                                 (FeatureCollection) getFeatureStore()
                                         .getDataCollection(featureQuery));
                     } catch (DataException ex) {
                         throw new SetFeatureValueException(rowIndex, columnIndex,
                                 value, ex);
+                    }
+                }
+            }
+        }
+    }

     /* gvSIG. Geographic Information System of the Valencian Government
+     *
      * Copyright (C) 2007-2008 Infrastructures and Transports Department
      * of the Valencian Gobernment (CIT)
+     *
      * This program is free software; you can redistribute it and/or
      * modify it under the terms of the GNU General Public License
      * as published by the Free Software Foundation; either version 2
      * of the License, or (at your option) any later version.
+     *
      * This program 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 General Public License for more details.
+     *
      * You should have received a copy of the GNU General Public License
      * along with this program; if not, write to the Free Software
      * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
      * MA  02110-1301, USA.
+     *
      */
     /*
      * AUTHORS (In addition to CIT):
      * 2008 {DiSiD Technologies}  {Create a JTable TableModel for a FeatureCollection}
      */
     package org.gvsig.fmap.data.feature.swing.table;
     import javax.swing.table.AbstractTableModel;
     import org.gvsig.fmap.data.ReadException;
     import org.gvsig.fmap.data.feature.*;
     import org.gvsig.fmap.data.feature.paging.FeatureCollectionPagingHelper;
     import org.gvsig.fmap.data.feature.paging.FeatureCollectionPagingHelperImpl;
     /**
      * TableModel to access data of a FeatureCollection.
+     *
      * @author <a href="mailto:cordin@disid.com">C?sar Ordi?ana</a>
      */
     public class FeatureCollectionTableModel extends AbstractTableModel {
         private static final long serialVersionUID = -2488157521902851301L;
         private FeatureCollectionPagingHelper helper;
         /**
          * Constructs a TableModel from a FeatureCollection, with the default page
          * size.
+         *
          * @param featureCollection
          *            to extract data from
          * @throws ReadException
          *             if there is an error reading data from the FeatureStore
          */
         public FeatureCollectionTableModel(FeatureStore featureStore,
                 FeatureQuery featureQuery) throws ReadException {
             this(featureStore, featureQuery,
                     FeatureCollectionPagingHelper.DEFAULT_PAGE_SIZE);
+        }
         /**
          * Constructs a TableModel from a FeatureCollection, and a given page size.
+         *
          * @param featureCollection
          *            to extract data from
          * @param pageSize
          *            the number of elements per page data
          * @throws ReadException
          *             if there is an error reading data from the FeatureStore
          */
         public FeatureCollectionTableModel(FeatureStore featureStore,
                 FeatureQuery featureQuery,
                 int pageSize) throws ReadException {
             this(new FeatureCollectionPagingHelperImpl(featureStore,
                     featureQuery,
                     pageSize));
+        }
         /**
          * Constructs a TableModel from a FeatureCollection and a Paging helper.
+         *
          * @param featureCollection
          *            to extract data from
          * @param helper
          *            the paging helper
          * @throws ReadException
          *             if there is an error reading data from the FeatureStore
          */
         public FeatureCollectionTableModel(FeatureCollectionPagingHelper helper) {
             this.helper = helper;
+        }
         public int getColumnCount() {
             // Return the number of fields of the Features
             FeatureType featureType = getFeatureType();
             return featureType.getFields().length;
+        }
         public int getRowCount() {
             // Return the total size of the collection
             return getHelper().getTotalSize();
+        }
         public Object getValueAt(int rowIndex, int columnIndex) {
             // Get the Feature at row "rowIndex", and return the value of the
             // attribute at "columnIndex"
             return getHelper().getFeatureAt(rowIndex).get(columnIndex);
+        }
         @SuppressWarnings("unchecked")
         public Class getColumnClass(int columnIndex) {
             // Return the class of the FeatureAttributeDescriptor for the value
             FeatureAttributeDescriptor attributeDesc = getAttributeDescriptor(columnIndex);
             Class clazz = attributeDesc.getObjectClass();
             return (clazz == null ? super.getColumnClass(columnIndex) : clazz);
+        }
         public String getColumnName(int column) {
             // Return the Feature attribute name
             FeatureAttributeDescriptor attributeDesc = getAttributeDescriptor(column);
             return attributeDesc.getName();
+        }
         /**
          * Returns a reference to the Paging Helper used to load the data from the
          * DataStore.
+         *
          * @return the paging helper
          */
         public FeatureCollectionPagingHelper getHelper() {
             return helper;
+        }
         /**
          * Returns the FeatureCollection used to get the data.
+         *
          * @return the FeatureCollection
          */
         protected FeatureCollection getFeatureCollection() {
             return getHelper().getFeatureCollection();
+        }
         /**
          * Returns the FeatureStore of the Collection.
+         *
          * @return the FeatureStore
          */
         protected FeatureStore getFeatureStore() {
             return getHelper().getFeatureStore();
+        }
         /**
          * Returns the type of the features.
          */
         private FeatureType getFeatureType() {
             return getFeatureCollection().getFeatureType();
+        }
         /**
          * Returns the descriptor of a Feature attribute.
          */
         private FeatureAttributeDescriptor getAttributeDescriptor(int columnIndex) {
             return getFeatureType().getByOrder(columnIndex);
+        }
+    }

     import javax.swing.table.AbstractTableModel;
     import org.gvsig.fmap.data.DataException;
     import org.gvsig.fmap.data.ReadException;
     import org.gvsig.fmap.data.exceptions.DataException;
     import org.gvsig.fmap.data.exceptions.ReadException;
     import org.gvsig.fmap.data.feature.*;
     import org.gvsig.fmap.data.feature.paging.FeaturePagingHelper;
     import org.gvsig.fmap.data.feature.paging.FeaturePagingHelperImpl;
-...
          *             if there is an error reading data from the FeatureStore
          */
         public FeatureTableModel(FeatureStore featureStore,
                 FeatureQuery featureQuery) throws ReadException {
                 FeatureQuery featureQuery) throws DataException {
             this(featureStore, featureQuery, FeaturePagingHelper.DEFAULT_PAGE_SIZE);
+        }
-...
          *             if there is an error reading data from the FeatureStore
          */
         public FeatureTableModel(FeatureStore featureStore,
                 FeatureQuery featureQuery, int pageSize) throws ReadException {
                 FeatureQuery featureQuery, int pageSize) throws DataException {
             this(new FeaturePagingHelperImpl(featureStore, featureQuery, pageSize));
+        }
-...
         public int getColumnCount() {
             // Return the number of fields of the Features
             FeatureType featureType = getFeatureType();
             return featureType.getFields().length;
             return featureType.size();
+        }
         public int getRowCount() {
-...
             return getFeatureStore().isEditing();
+        }
         /**
          * TODO: the current implementation does not work, update to the last API
          * changes for Feature edition.
          */
         @Override
         public void setValueAt(Object value, int rowIndex, int columnIndex) {
             // Get the feature at rowIndex
-...
                 if (value != currentValue
                         || (value != null && !value.equals(currentValue))) {
                     try {
                         // getFeatureStore().startEditing();
                         //
                         // EditableFeature editable = feature.getEditableFeature();
                         // editable.set(columnIndex, value);
                         //
                         // getFeatureStore().update(editable);
                         // getFeatureStore().finishEditing();
                         FeatureStore store = getFeatureStore();
                         store.edit();
                         store.update(setFeatureValue(feature, columnIndex, value));
                         store.finishEditing();
                         getFeatureStore().startEditing();
                         feature.editing();
                         setFeatureValue(feature, columnIndex, value);
                         getFeatureStore().update(feature);
                         // getHelper().reload();
                         // TODO: REVISAR
                         // getHelper().setFeatureCollection(
                         // (FeatureCollection) getFeatureStore()
                         // .getDataCollection(getFeatureQuery()));
                         getHelper().reloadCurrentPage();
                         fireTableCellUpdated(rowIndex, columnIndex);
                     } catch (DataException ex) {
                         throw new SetFeatureValueException(rowIndex, columnIndex,
-...
+        }
         /**
          * Sets the FeatureType to show in the table. Used for FeatureStores with
          * many simultaneous FeatureTypes supported. Will cause a reload of the
          * current data.
+         *
          * @param featureType
          *            the FeatureType of the Features
          * @throws DataException
          *             if there is an error loading the data
          */
         public void setFeatureType(FeatureType featureType) throws DataException {
             getFeatureQuery().setFeatureType(featureType);
             getHelper().reload();
             fireTableStructureChanged();
+        }
         /**
          * Initialize the TableModel
          */
         protected void initialize() {
-...
          * @throws IsNotFeatureSettingException
          *             if there is an error setting the value
          */
         protected void setFeatureValue(Feature feature, int columnIndex,
                 Object value) throws IsNotFeatureSettingException {
             feature.set(columnIndex, value);
         protected EditableFeature setFeatureValue(Feature feature, int columnIndex,
                 Object value) {
             EditableFeature editableFeature = feature.getEditable();
             editableFeature.set(columnIndex, value);
             return editableFeature;
+        }
         /**
-...
         protected FeatureQuery getFeatureQuery() {
             return getHelper().getFeatureQuery();
+        }
         /**
          * Returns the type of the features.
          */
         private FeatureType getFeatureType() {
             return getFeatureCollection().getFeatureType();
             return getFeatureQuery().getFeatureType();
+        }
         /**
          * Returns the descriptor of a Feature attribute.
          */
         private FeatureAttributeDescriptor getAttributeDescriptor(int columnIndex) {
             return getFeatureType().getByOrder(columnIndex);
             return getFeatureType().getAttributeDescriptor(columnIndex);
+        }
+    }

     import java.util.*;
     import org.gvsig.fmap.data.ReadException;
     import org.gvsig.fmap.data.exceptions.DataException;
     import org.gvsig.fmap.data.feature.*;
     import org.gvsig.fmap.data.feature.paging.FeaturePagingHelper;
-...
         private List<String> columnNames;
         private List<String> visibleColumnNames;
         private Map<String, String> name2Alias;
         /**
          * @see FeatureTableModel#FeatureTableModel(FeatureStore, FeatureQuery)
          */
         public ConfigurableFeatureTableModel(FeatureStore featureStore,
                 FeatureQuery featureQuery) throws ReadException {
                 FeatureQuery featureQuery) throws DataException {
             super(featureStore, featureQuery);
+        }
-...
          * @see FeatureTableModel#FeatureTableModel(FeatureStore, FeatureQuery, int)
          */
         public ConfigurableFeatureTableModel(FeatureStore featureStore,
                 FeatureQuery featureQuery, int pageSize) throws ReadException {
                 FeatureQuery featureQuery, int pageSize) throws DataException {
             super(featureStore, featureQuery, pageSize);
+        }
-...
                 visibleColumnNames.remove(name);
                 fireTableStructureChanged();
+            }
+        }
         /**
-...
             visibleColumnNames.addAll(columnNames);
             fireTableStructureChanged();
+        }
         /**
          * Sets the alias for a column.
+         *
-...
             name2Alias.put(name, alias);
             fireTableStructureChanged();
+        }
         public void orderByColumn(String name, boolean ascending)
                 throws ReadException {
             String order = ascending ? name.concat(" ASC") : name.concat(" DESC");
             getHelper().getFeatureQuery().setOrder(order);
                 throws DataException {
             FeatureQueryOrder order = getHelper().getFeatureQuery().getOrder();
             order.add(name, ascending);
             getHelper().reload();
             fireTableDataChanged();
+        }
-...
         private void initializeAliases() {
             int columns = super.getColumnCount();
             name2Alias = new HashMap<String, String>(columns);
             for (int i = 0; i < columns; i++) {
                 String columnName = super.getColumnName(i);
                 name2Alias.put(columnName, columnName);
-...
                 visibleColumnNames.add(columnName);
+            }
+        }
         /**
          * Returns the alias for the name of a column.
+         *
-...
+        }
         @Override
         protected void setFeatureValue(Feature feature, int columnIndex,
                 Object value) throws IsNotFeatureSettingException {
         protected EditableFeature setFeatureValue(Feature feature, int columnIndex,
                 Object value) {
             int realColumnIndex = getRealColumnIndex(columnIndex);
             super.setFeatureValue(feature, realColumnIndex, value);
             return super.setFeatureValue(feature, realColumnIndex, value);
+        }
+    }

Also available in: Unified diff