/ - Diff - Application: gvSIG desktop - gvSIG

Revision 46134

     package org.gvsig.fmap.mapcontext.layers;
     import java.util.ArrayList;
     import java.util.HashMap;
     import java.util.Iterator;
     import java.util.List;
     import java.util.Map;
     import org.gvsig.fmap.geom.Geometry;
     import org.gvsig.fmap.geom.GeometryLocator;
     import org.gvsig.fmap.geom.SpatialIndex;
-...
     import org.slf4j.Logger;
     import org.slf4j.LoggerFactory;
     public class SpatialCache  {
     public class SpatialCache {
         private static final Logger logger = LoggerFactory.getLogger(SpatialCache.class);
         private int maxFeatures = 1000; // Por defecto, pero se puede cambiar
     	private int fastNumTotalRegs=0;
     	private SpatialIndex index = null;
             private boolean overflown = false;
     	private boolean enabled = false;
         private int fastNumTotalRegs = 0;
         private SpatialIndex index = null;
         private boolean overflown = false;
         private Map<String, Boolean> enabledContexts;
     	public SpatialCache() {
     		try {
     			this.index = GeometryLocator.getGeometryManager().createDefaultMemorySpatialIndex();
     		} catch (Exception e) {
     			logger.info("Can't create spatial index", e);
+    		}
+    	}
     	public int getMaxFeatures() {
     		return maxFeatures;
+    	}
         private boolean enabled = false;
     	public void setMaxFeatures(int maxFeatures) {
     		this.maxFeatures = maxFeatures;
+    	}
         public SpatialCache() {
             enabledContexts = new HashMap<>();
             try {
                 this.index = GeometryLocator.getGeometryManager().createDefaultMemorySpatialIndex();
             } catch (Exception e) {
                 logger.info("Can't create spatial index", e);
+            }
+        }
     	public synchronized void insert(Envelope bounds, Geometry geom) {
     		if (isEnabled()) {
                         if (getMaxFeatures() >= size()) {
                             this.index.insert(bounds, geom);
     			fastNumTotalRegs++;
                         } else {
                             overflown = true;
+                        }
+    		}
+    	}
         public int getMaxFeatures() {
             return maxFeatures;
+        }
     	public synchronized void query(Envelope searchEnv, Visitor visitor)
+    	{
     		this.index.query(searchEnv, visitor);
+    	}
     	public synchronized List query(Envelope searchEnv)
+    	{
     		List result = new ArrayList();
     		Iterator it = index.query(searchEnv);
     		while( it.hasNext() ) {
     			result.add( it.next());
+    		}
     		return result;
+    	}
         public void setMaxFeatures(int maxFeatures) {
             this.maxFeatures = maxFeatures;
+        }
     	public void insert(Envelope itemEnv, Object item) {
     		if (isEnabled()) {
                         if (getMaxFeatures() >= size()) {
     			this.index.insert(itemEnv, item);
     			fastNumTotalRegs++;
                         } else {
                             overflown = true;
+                        }
+    		}
+    	}
         public synchronized void insert(Envelope bounds, Geometry geom) {
             if (isEnabled()) {
                 if (getMaxFeatures() >= size()) {
                     this.index.insert(bounds, geom);
                     fastNumTotalRegs++;
                 } else {
                     overflown = true;
+                }
+            }
+        }
     	public boolean remove(Envelope itemEnv, Object item) {
     		boolean resul = this.index.remove(itemEnv,item);
     		if (resul)
     			fastNumTotalRegs--;
     		return resul;
+    	}
         public synchronized void query(Envelope searchEnv, Visitor visitor) {
             this.index.query(searchEnv, visitor);
     	public int size() {
     		return fastNumTotalRegs;
+    	}
+        }
     	public void clearAll() {
     		index.removeAll();
     		fastNumTotalRegs = 0;
                     overflown = false;
+    	}
         public synchronized List query(Envelope searchEnv) {
             List result = new ArrayList();
             Iterator it = index.query(searchEnv);
             while (it.hasNext()) {
                 result.add(it.next());
+            }
             return result;
+        }
     	public void remove(org.gvsig.fmap.geom.primitive.Envelope bounds, Geometry geom) {
         public void insert(Envelope itemEnv, Object item) {
             if (isEnabled()) {
                 if (getMaxFeatures() >= size()) {
                     this.index.insert(itemEnv, item);
                     fastNumTotalRegs++;
                 } else {
                     overflown = true;
+                }
+            }
+        }
         public boolean remove(Envelope itemEnv, Object item) {
             boolean resul = this.index.remove(itemEnv, item);
             if (resul) {
                 fastNumTotalRegs--;
+            }
             return resul;
+        }
         public int size() {
             return fastNumTotalRegs;
+        }
         public void removeAll() {
             index.removeAll();
             fastNumTotalRegs = 0;
             overflown = false;
+        }
         public void remove(org.gvsig.fmap.geom.primitive.Envelope bounds, Geometry geom) {
             index.remove(bounds, geom);
+    	}
+        }
     	public boolean isEnabled() {
     		return enabled;
+    	}
         public boolean isEnabled() {
             if (enabled) {
                 return true;
+            }
             for (Boolean value : this.enabledContexts.values()) {
                 if (value) {
                     return true;
+                }
+            }
             return false;
+        }
     	public void setEnabled(boolean enabled) {
     		this.enabled = enabled;
+    	}
             public boolean isOverflown() {
                 return overflown;
         public boolean isEnabled(String contextId) {
             return this.enabledContexts.getOrDefault(contextId, false);
+        }
         public void setEnabled(boolean enabled) {
             this.enabled = enabled;
+        }
         public void setEnabled(String contextId, boolean enabled) {
             this.enabledContexts.put(contextId, enabled);
+        }
         public boolean isOverflown() {
             return overflown;
+        }
         public boolean isContextEnabled() {
             for (Boolean value : this.enabledContexts.values()) {
                 if (value) {
                     return true;
+                }
+            }
             return false;
+        }
+    }

+            }
             if (spatialCache.isEnabled()) {
                 spatialCache.clearAll();
                 spatialCache.removeAll();
                 legend.addDrawingObserver(this);
+            }
-...
                     throw new StartEditionLayerException(getName(), e);
+                }
+            }
             setSpatialCacheEnabled(b);
             getSpatialCache().setEnabled("editing", b);
             callEditionChanged(LayerEvent.createEditionChangedEvent(this, "edition"));
+        }
-...
          * @deprecated Use {@link #getSpatialCache()}
          */
         public void clearSpatialCache() {
             spatialCache.clearAll();
             spatialCache.removeAll();
+        }
         /**
-...
                         this.updateDrawVersion();
                     } else if (event.getType() == FeatureStoreNotification.AFTER_CANCELEDITING) {
                         getSpatialCache().setEnabled("editing", false);
                         setSpatialCacheEnabled(false);
                         callEditionChanged(LayerEvent.createEditionChangedEvent(this, "edition"));
                         this.updateDrawVersion();
                     } else if (event.getType() == FeatureStoreNotification.AFTER_STARTEDITING) {
                         setSpatialCacheEnabled(true);
                         getSpatialCache().setEnabled("editing", true);
                         callEditionChanged(LayerEvent.createEditionChangedEvent(this, "edition"));
                     } else if (event.getType() == FeatureStoreNotification.TRANSFORM_CHANGE) {
-...
                         this.setAvailable(false);
                     } else if (event.getType() == FeatureStoreNotification.AFTER_FINISHEDITING) {
                         this.setAvailable(true);
                         setSpatialCacheEnabled(false);
                         getSpatialCache().setEnabled("editing", false);
                         callEditionChanged(LayerEvent.createEditionChangedEvent(this, "edition"));
                         this.updateDrawVersion();
+                    }
-...
         @Override
         protected void doDispose() throws BaseException {
             dispose(featureStore);
             spatialCache.clearAll();
             spatialCache.removeAll();
+        }
         /**

                 private final FLyrVect layer;
                 private boolean selected;
                 private int cacheFeatures;
                 private final boolean contextEnabled;
                 public TableRow(FLyrVect layer, boolean selected, int cacheFeatures) {
                 public TableRow(FLyrVect layer, boolean selected, boolean contextEnabled, int cacheFeatures) {
                     this.layer = layer;
                     this.selected = selected;
                     this.contextEnabled = contextEnabled;
                     this.cacheFeatures = cacheFeatures;
+                }
-...
                     case 0:
                         return row.isSelected();
                     case 1:
                         if(row.contextEnabled){
                             return "<html><b>"+row.getLayer().getName()+"</b></html>";
+                        }
                         return row.getLayer().getName();
                     case 2:
                         return row.getCacheFeatures();
-...
                     TableRow row = new TableRow(
                             layerVect,
                             spatialCache.isEnabled(),
                             spatialCache.isContextEnabled(),
                             spatialCache.getMaxFeatures()
                     );
                     rows.add(row);

Also available in: Unified diff