/ - Diff - Application: gvSIG desktop - gvSIG

Revision 42639

      * @author 2010- C?sar Ordi?ana - gvSIG team
      */
     public class FeatureSelectionModel implements ListSelectionModel, Observer {
         private static Logger LOG =
         private static Logger LOG =
             LoggerFactory.getLogger(FeatureSelectionModel.class);
     	protected EventListenerList listenerList = new EventListenerList();
     	private final FeatureTableModel featureTableModel;
-...
     	private int anchor = -1;
     	private int lead = -1;
     	private int currentFirst = -1;
     	private int currentLast = -1;
-...
     	 * Creates a new {@link FeatureSelectionModel} with a
     	 * {@link FeatureTableModel} used to get the {@link Feature}s by position in
     	 * the table.
+    	 *
+    	 *
     	 * @param featureTableModel
     	 *            to get Features from
     	 * @throws DataException
-...
+    	}
     	public int getMaxSelectionIndex() {
     	    int resp = this.getSelectionIndex(true);
     	    return resp;
     	    /*
+    	     *
+    	     *
     	     * The call to "featureTableModel.getFeatureAt(i)"
     	     * causes a lot of reloadPage all over
+    	     *
+    	     *
     		FeatureSelection selection = getFeatureSelection();
     		try {
     			if (!selection.isEmpty()) {
-...
     	    int resp = this.getSelectionIndex(false);
     	    return resp;
     	    /*
+    	     *
+    	     *
              * The call to "featureTableModel.getFeatureAt(i)"
              * causes a lot of reloadPage all over
+    	     *
+    	     *
     		try {
     		    int ii = 0;
-...
     			throw new SelectionChangeException(e);
+    		}
     		*/
+    	}
     	public void insertIndexInterval(int index, int length, boolean before) {
-...
+    	}
     	public void addSelectionInterval(int index0, int index1) {
     		doWithSelection(new FeatureSelectionOperation() {
     	    if (!featureTableModel.isSelectionLocked()){
     	        doWithSelection(new FeatureSelectionOperation() {
     			public void doWithSelection(FeatureSelection selection, int first,
     					int last) throws DataException {
     				for (int i = first; i <= last; i++) {
     					Feature feature = getFeature(i);
     					if (!selection.isSelected(feature)) {
     						selection.select(feature);
+    					}
+    				}
+    			}
     	            public void doWithSelection(FeatureSelection selection, int first,
     	                int last) throws DataException {
     	                for (int i = first; i <= last; i++) {
     	                    Feature feature = getFeature(i);
     	                    if (!selection.isSelected(feature)) {
     	                        selection.select(feature);
+    	                    }
+    	                }
+    	            }
     		}, index0, index1, true);
     	        }, index0, index1, true);
+    	    }
+    	}
     	public void setSelectionInterval(int index0, int index1) {
     		doWithSelection(new FeatureSelectionOperation() {
     	    if (!featureTableModel.isSelectionLocked()){
     	        doWithSelection(new FeatureSelectionOperation() {
     			public void doWithSelection(FeatureSelection selection, int first,
     					int last) throws DataException {
     				selection.deselectAll();
     				for (int i = first; i <= last; i++) {
     					Feature feature = getFeature(i);
     					selection.select(feature);
+    				}
+    			}
     	            public void doWithSelection(FeatureSelection selection, int first,
     	                int last) throws DataException {
     	                selection.deselectAll();
     	                for (int i = first; i <= last; i++) {
     	                    Feature feature = getFeature(i);
     	                    selection.select(feature);
+    	                }
+    	            }
     		}, index0, index1, true);
     	        }, index0, index1, true);
+    	    }
+    	}
     	public void removeSelectionInterval(int index0, int index1) {
     		doWithSelection(new FeatureSelectionOperation() {
     	    if (!featureTableModel.isSelectionLocked()){
     	        doWithSelection(new FeatureSelectionOperation() {
     			public void doWithSelection(FeatureSelection selection, int first,
     					int last) throws DataException {
     				for (int i = first; i <= last; i++) {
     					Feature feature = getFeature(i);
     					if (selection.isSelected(feature)) {
     						selection.deselect(feature);
+    					}
+    				}
+    			}
     	            public void doWithSelection(FeatureSelection selection, int first,
     	                int last) throws DataException {
     	                for (int i = first; i <= last; i++) {
     	                    Feature feature = getFeature(i);
     	                    if (selection.isSelected(feature)) {
     	                        selection.deselect(feature);
+    	                    }
+    	                }
+    	            }
     		}, index0, index1, false);
     	        }, index0, index1, false);
+    	    }
+    	}
     	public void clearSelection() {
     		try {
     			getFeatureSelection().deselectAll();
     		} catch (DataException e) {
     			throw new SelectionChangeException(e);
+    		}
     	    if (!featureTableModel.isSelectionLocked()){
     	        try {
     	            getFeatureSelection().deselectAll();
     	        } catch (DataException e) {
     	            throw new SelectionChangeException(e);
+    	        }
+    	    }
+    	}
     	public boolean isSelectedIndex(int index) {
-...
     		// values
     		int first = (index0 <= index1) ? index0 : index1;
     		int last = (index0 <= index1) ? index1 : index0;
     		//If the new selection is not updated don't continue
     		if ((currentFirst == first) && (currentLast == last)){
     		    return;
-...
     		void doWithSelection(FeatureSelection selection, int first, int last)
     				throws DataException;
+    	}
     	/**
+    	 *
     	 * Return the index of the the first (last) selected feature
+    	 *
     	 * @param last whether to return the index of the last selected feature
+    	 *
     	 * Return the index of the the first (last) selected feature
+    	 *
     	 * @param last whether to return the index of the last selected feature
     	 * @return
     	 */
     	private int getSelectionIndex(boolean last) {
             int ind = -1;
             int resp = -1;
-...
             try {
                 FeatureSelection selection = getFeatureSelection();
                 if (!selection.isEmpty()) {
                     fs = getFeatureStore().getFeatureSet();
                     diter = fs.fastIterator();
                     Feature feat = null;
-...
+                            }
+                        }
+                    }
+                }
             } catch (DataException e) {
                 throw new SelectionChangeException(e);
-...
                     fs.dispose();
+                }
+            }
             return resp;
             return resp;
+    	}
+    }

     import java.awt.event.ActionEvent;
     import java.awt.event.ActionListener;
     import javax.swing.SwingUtilities;
     import javax.swing.Timer;
     import javax.swing.event.TableModelEvent;
     import javax.swing.table.AbstractTableModel;
     import org.gvsig.editing.EditingNotification;
     import org.gvsig.editing.EditingNotificationManager;
     import org.gvsig.fmap.dal.DALLocator;
     import org.gvsig.fmap.dal.exception.DataException;
     import org.gvsig.fmap.dal.feature.EditableFeature;
-...
         /** Used to know if a modification in the FeatureStore is created by us. */
         private EditableFeature editableFeature;
         private boolean selectionLocked=false;
         /**
          * Constructs a TableModel from the features of a FeatureStore, with the
          * default page size.
-...
         public void setFeatureType(FeatureType featureType) {
             getFeatureQuery().setFeatureType(featureType);
             reloadFeatures();
             fireTableStructureChanged();
             //Selection must be locked to avoid losing it when the table is refreshed
             selectionLocked=true;
             //The table is refreshed
             try {
                 fireTableStructureChanged();
             } catch (Exception e) {
                 logger.warn("Couldn't reload changed table");
             }finally{
                 //The locked selection is unlocked.
                 selectionLocked=false;
+            }
+        }
         /**
-...
             // changed through us.
             if (editableFeature == null || !editableFeature.equals(feature)) {
                 reloadFeatures();
                 fireTableDataChanged();
                 //Selection must be locked to avoid losing it when the table is refreshed
                 selectionLocked=true;
                 //The table is refreshed
                 try {
                     fireTableDataChanged();
                 } catch (Exception e) {
                     logger.warn("Couldn't reload changed table");
                 }finally{
                     //The locked selection is unlocked.
                     selectionLocked=false;
+                }
+            }
+        }
-...
                 throw new FeaturesDataReloadException(ex);
+            }
+        }
         /**
          * Returns true if selection must not be changed.
          * @return
          */
         public boolean isSelectionLocked() {
             return selectionLocked;
+        }
+    }

     	private Map added = new LinkedHashMap();
     	private Map addedAndDeleted = new LinkedHashMap();
     	private HashMap modifiedFromOriginal=new HashMap();
     	public FeatureManager(ExpansionAdapter expansionAdapter){
         	this.expansionAdapter=expansionAdapter;
+        }
     	/**
     	 * Deletes feature from this manager.
     	 * @param id
     	 * Deletes feature from this manager.
     	 * @param id
     	 * @return The deleted feature or null if the
     	 * feature had not been edited or previously added in the editing session
     	 * feature had not been edited or previously added in the editing session
     	 */
         public Feature delete(FeatureReference id) {
             deleted.add(id);
-...
         	Integer intNum = ((Integer) added.get(id));
         	if (intNum == null){
         		intNum =((Integer) modifiedFromOriginal.get(id));
             	if (intNum == null){
             	if (intNum == null){
             	    //If the feature has been added and deleted
             	    intNum = (Integer)addedAndDeleted.get(id);
             	    if (intNum == null){
-...
     	public long getDeltaSize() {
     		return deltaSize;
+    	}
         /**
          * Indicates if any operation has comprimised the selected features.
          * @return
          */
         public boolean isSelectionCompromised() {
             //Only deleted features can change order, as added features are added at the end.
             return deleted.size()>0;
+        }
+    }

                  * to prevent conflicts with selection remaining from
                  * editing mode.
                  */
                 ((FeatureSelection) this.getSelection()).deselectAll();
     //            ((FeatureSelection) this.getSelection()).deselectAll();
                 switch (mode) {
                 case MODE_QUERY:
                     throw new NeedEditingModeException(this.getName());
                 case MODE_APPEND:
                     ((FeatureSelection) this.getSelection()).deselectAll();
                     notifyChange(FeatureStoreNotification.BEFORE_FINISHEDITING);
                     provider.endAppend();
                     exitEditingMode();
-...
                     if (hasStrongChanges && !this.allowWrite()) {
                         throw new WriteNotAllowedException(getName());
+                    }
                     if(featureManager.isSelectionCompromised()) {
                         ((FeatureSelection) this.getSelection()).deselectAll();
                     };
                     notifyChange(FeatureStoreNotification.BEFORE_FINISHEDITING);
                     if (hasStrongChanges) {
                         validateFeatures(Feature.FINISH_EDITING);

Also available in: Unified diff