/ - Diff - | gvSIG desktop 1 - gvSIG

+    	 *
     	 * @param layerName the name of the layer to be replaced
     	 * @param layer the new layer
     	 * @deprecated use {@link FLayers#replaceLayer(FLayer, FLayer)}
     	 */
     	public void replaceLayer(String layerName, FLayer layer) throws LoadLayerException
+    	{
     		FLayer lyr;
     		FLayer parent;
     		for (int i = 0; i < layers.size(); i++) {
     			lyr = ((FLayer) layers.get(i));
     			if (lyr.getName().compareToIgnoreCase(layerName) == 0) {
     				parent = lyr.getParentLayer();
     				removeLayer(i);
     				if (parent != null) {
     					//Notificamos a la capa que va a ser a?adida
     					if (layer instanceof FLyrDefault) {
     						((FLyrDefault)layer).wakeUp();
+    					}
+    				}
     				if (layer instanceof FLayers){
     					FLayers layers=(FLayers)layer;
     					fmap.addAsCollectionListener(layers);
+    				}
     				callLayerAdding(LayerCollectionEvent.createLayerAddingEvent(layer));
     //				layers.add(i,layer);
     //				layer.setParentLayer(this);
     				this.doAddLayer(i, layer);
     				callLayerAdded(LayerCollectionEvent.createLayerAddedEvent(layer));
     				break;
+    			}
+    		}
     		replaceLayer(getLayer(layerName), layer);
+    	}
     	/**
          * Replace a layer by another layer.  It search recursively by all the
          * ILayerCollection nodes
+         *
          * @param layer
          *          the layer to be replaced
          * @param newLayer
          *          the new layer
          */
         public void replaceLayer(FLayer layer, FLayer newLayer) throws LoadLayerException
+        {
             replaceLayer(this, layer, newLayer);
+        }
         /**
          * Replace a layer by other layer. It search recursively by all the
          * ILayerCollection nodes
          * @param parentLayer
          *          the parent layer
          * @param layer
          *          the layer to be replaced
          * @param newLayer
          *          the new layer
          * @throws LoadLayerException
          */
         private void replaceLayer(FLayers parentLayer, FLayer layer, FLayer newLayer) throws LoadLayerException
+        {
             FLayer lyr;
             for (int i = 0; i < parentLayer.getLayersCount(); i++) {
                 lyr = ((FLayer) parentLayer.getLayer(i));
                 if (lyr.equals(layer)) {
                     parentLayer.removeLayer(i);
                     parentLayer.addLayer(i, newLayer);
                     break;
+                }
                 if (lyr instanceof LayerCollection){
                     replaceLayer((FLayers)lyr, layer, newLayer);
+                }
+            }
+        }
     	/*
     	 * (non-Javadoc)

      */
     package org.gvsig.fmap.mapcontext.layers.vectorial;
     import java.util.Iterator;
     import org.gvsig.fmap.geom.Geometry;
     import org.gvsig.fmap.mapcontext.MapContext;
     import org.gvsig.fmap.mapcontext.rendering.symbols.ISymbol;
-...
     	public int getSymbolId(ISymbol symbol);
     	/**
     	 * Adds a new {@link Geometry} to be rendered into the layer.
+    	 *
     	 * @param groupId
     	 *            group identifier. Allows to identify a group of
     	 *            {@link Geometry} added to the layer
     	 * @param geom
     	 *            the {@link Geometry} to add
     	 * @param idsym
     	 *            the {@link ISymbol} identifier to apply to render the
     	 *            {@link Geometry}
     	 */
     	public void addGraphic(String groupId, Geometry geom, int idsym);
     	/**
     	 * @deprecated @see
     	 *             {@link #addGraphic(String, Geometry, int, String, Object, int)
-...
     	 */
     	public void addGraphic(Geometry geom, int idsym, String label);
         /**
          * Adds a new {@link Geometry} to be rendered into the layer.
+         *
          * @param groupId
          *            group identifier. Allows to identify a group of
          *            {@link Geometry} added to the layer
          * @param geom
          *            the {@link Geometry} to add
          * @param idsym
          *            the {@link ISymbol} identifier to apply to render the
          *            {@link Geometry}
          */
         public void addGraphic(String groupId, Geometry geom, int idsym);
     	/**
     	 * Adds a new {@link Geometry} to be rendered into the layer.
+    	 *
-...
     	public void addGraphic(String groupId, Geometry geom, int idsym,
     			String label, Object tag, int priority);
         /**
          * Adds a new {@link Geometry} to be rendered into the layer.
+         *
          * @param groupId
          *            group identifier. Allows to identify a group of
          *            {@link Geometry} added to the layer
          * @param geoms
          *            the {@link Geometry}s to add
          * @param idsym
          *            the {@link ISymbol} identifier to apply to render the
          *            {@link Geometry}
          */
         public void addGraphics(String groupId, Iterator geoms, int idsym);
         /**
          * Adds a new {@link Geometry} to be rendered into the layer.
+         *
          * @param groupId
          *            group identifier. Allows to identify a group of
          *            {@link Geometry} added to the layer
          * @param geoms
          *            the {@link Geometry}s to add
          * @param idsym
          *            the {@link ISymbol} identifier to apply to render the
          *            {@link Geometry}
          * @param label
          *            the text to show if the {@link ISymbol} is a
          *            {@link ITextSymbol}. Set null otherwise.
          */
         public void addGraphics(String groupId, Iterator geoms, int idsym,
             String label);
         /**
          * Adds a new {@link Geometry} to be rendered into the layer.
+         *
          * @param groupId
          *            group identifier. Allows to identify a group of
          *            {@link Geometry} added to the layer
          * @param geoms
          *            the {@link Geometry}s to add
          * @param idsym
          *            the {@link ISymbol} identifier to apply to render the
          *            {@link Geometry}
          * @param label
          *            the text to show if the {@link ISymbol} is a
          *            {@link ITextSymbol}. Set null otherwise.
          * @param tag
          *            an object to classify, identify or add related information to
          *            the {@link Geometry}
          * @param priority
          *            to apply while rendering the {@link Geometry}. Values with
          *            lower priority will be rendered first.
          */
         public void addGraphics(String groupId, Iterator geoms, int idsym,
             String label, Object tag, int priority);
     	/**
     	 * Removes all previously registered {@link Geometry} objects from the layer
     	 * with the given groupId.

     */
     package org.gvsig.fmap.mapcontext.layers.vectorial.impl;
     import java.util.Iterator;
     import org.cresques.cts.IProjection;
     import org.slf4j.Logger;
     import org.slf4j.LoggerFactory;
     import org.gvsig.fmap.dal.DALLocator;
     import org.gvsig.fmap.dal.DataManager;
     import org.gvsig.fmap.dal.DataTypes;
     import org.gvsig.fmap.dal.exception.DataException;
     import org.gvsig.fmap.dal.exception.ValidateDataParametersException;
     import org.gvsig.tools.dispose.DisposableIterator;
     import org.gvsig.fmap.dal.feature.EditableFeature;
     import org.gvsig.fmap.dal.feature.EditableFeatureAttributeDescriptor;
     import org.gvsig.fmap.dal.feature.EditableFeatureType;
-...
     import org.gvsig.fmap.mapcontext.rendering.legend.IVectorLegend;
     import org.gvsig.fmap.mapcontext.rendering.legend.IVectorialUniqueValueLegend;
     import org.gvsig.fmap.mapcontext.rendering.symbols.ISymbol;
     import org.gvsig.tools.dispose.DisposableIterator;
     import org.gvsig.tools.exception.BaseException;
     import org.slf4j.Logger;
     import org.slf4j.LoggerFactory;
     /**
      * Default {@link GraphicLayer} implementation.
-...
     			if (!store.isEditing()){
     				store.edit(FeatureStore.MODE_APPEND);
+    			}
     			EditableFeature feature = store.createNewFeature().getEditable();
     			feature.setString(GraphicLayer.FEATURE_ATTR_GROUPID, groupId);
     			feature.setGeometry(GraphicLayer.FEATURE_ATTR_GEOMETRY, geom);
     			feature.setInt(GraphicLayer.FEATURE_ATTR_IDSYMBOL, idsym);
     			feature.setString(GraphicLayer.FEATURE_ATTR_LABEL, label);
     			feature.setLong(GraphicLayer.FEATURE_ATTR_FEATUREID, ids);
     			feature.set(GraphicLayer.FEATURE_ATTR_TAG, tag);
     			feature.setInt(GraphicLayer.FEATURE_ATTR_PRIORITY, priority);
     			ids++;
     			store.insert(feature);
     			insertGeometry(groupId, geom, idsym, label, tag, priority);
     			store.finishEditing();
     		} catch (DataException e) {
     			logger.error("Error adding a geometry to the graphic layer", e);
+    		}
+    	}
+    	}
         private void insertGeometry(String groupId, Geometry geom, int idsym,
             String label, Object tag, int priority) throws DataException {
             EditableFeature feature = store.createNewFeature().getEditable();
             feature.setString(GraphicLayer.FEATURE_ATTR_GROUPID, groupId);
             feature.setGeometry(GraphicLayer.FEATURE_ATTR_GEOMETRY, geom);
             feature.setInt(GraphicLayer.FEATURE_ATTR_IDSYMBOL, idsym);
             feature.setString(GraphicLayer.FEATURE_ATTR_LABEL, label);
             feature.setLong(GraphicLayer.FEATURE_ATTR_FEATUREID, ids);
             feature.set(GraphicLayer.FEATURE_ATTR_TAG, tag);
             feature.setInt(GraphicLayer.FEATURE_ATTR_PRIORITY, priority);
             ids++;
             store.insert(feature);
+        }
         public void addGraphics(String groupId, Iterator geoms, int idsym) {
             addGraphics(groupId, geoms, idsym, null, null, DEFAULT_PRIORITY);
+        }
         public void addGraphics(String groupId, Iterator geoms, int idsym,
             String label) {
             addGraphics(groupId, geoms, idsym, label, null, DEFAULT_PRIORITY);
+        }
         public void addGraphics(String groupId, Iterator geoms, int idsym,
             String label, Object tag, int priority) {
             try {
                 if (!store.isEditing()) {
                     store.edit(FeatureStore.MODE_APPEND);
+                }
                 for (; geoms.hasNext();) {
                     Geometry geom = (Geometry) geoms.next();
                     insertGeometry(groupId, geom, idsym, label, tag, priority);
+                }
                 store.finishEditing();
             } catch (DataException e) {
                 logger.error("Error adding a geometry to the graphic layer", e);
+            }
+        }
     	public int addSymbol(ISymbol newSymbol) {
     		symbolId++;
     		legend.addSymbol(new Integer(symbolId), newSymbol);

     		this.parentLayer = (FLayers) state.get("parentLayer");
     		this.status = (FLayerStatus) state.get("status");
     		this.minScale = state.getDouble("minScale");
     		this.minScale = state.getDouble("maxScale");
     		this.maxScale = state.getDouble("maxScale");
     		this.transparency = state.getInt("transparency");
     		this.ct = (ICoordTrans) state.get("coordTrans");

     import java.util.Collections;
     import java.util.HashMap;
     import java.util.Map;
     import java.util.Random;
     import org.cresques.cts.IProjection;
     import org.slf4j.Logger;
-...
     	public IVectorLegend createDefaultVectorLegend(int shapeType)
     	throws MapContextRuntimeException {
     		try {
     			Random rand = new Random();
     			int numreg = rand.nextInt(255 / 2);
     			double div = (1 - rand.nextDouble() * 0.66) * 0.9;
     			Color randomColor = new Color(((int) (255 * div + (numreg * rand
     					.nextDouble()))) % 255, ((int) (255 * div + (numreg * rand
     							.nextDouble()))) % 255, ((int) (255 * div + (numreg * rand
     									.nextDouble()))) % 255);
     			IVectorLegend legend = (IVectorLegend) createLegend(getDefaultVectorLegend());
     			if( legend == null ) {
     				return null;
+    			}
     			ISymbol defaultSymbol =
     				getSymbolManager().createSymbol(shapeType, randomColor);
     			legend.setDefaultSymbol(defaultSymbol);
                 // Create legend
                 IVectorLegend legend =
                     (IVectorLegend) createLegend(getDefaultVectorLegend());
                 if (legend == null) {
                     return null;
+                }
                 // Set legend values
                 legend.setDefaultSymbol(getSymbolManager().createSymbol(shapeType));
     			legend.setShapeType(shapeType);
     			return legend;
     		} catch(Exception e) {
-...
     		ILegend legend = null;
     		//Loading the legend from a store based on file
             DataServerExplorer dataServerExplorer = null;
     		try {
     //			This access by reflection is done because the libFMap_dalfile project
     //			has to be divided in several projects. The commented code is the fine
-...
     //					legend = (ILegend)persistenceManager.create(persistentState);
     //				}
     //			}
     			DataServerExplorer dataServerExplorer = dataStore.getExplorer();
                 dataServerExplorer = dataStore.getExplorer();
     			Class[] args = new Class[2];
     			args[0] = DataStore.class;
     			args[1] = String.class;
-...
+    			}
     		} catch (Exception e) {
     			LOG.info("Can't load the specific legend provided by the explorer.", e);
                 LOG.debug(
                     "Can't load the specific legend provided by the explorer "
                         + dataServerExplorer, e);
+    		}
     		//If the legend is null, next option is to check if the store has the getLegend method
-...
     				legend = (IVectorLegend) dataStore.invokeDynMethod(
     						"getLegend", null);
     			} catch (DynMethodNotSupportedException e) {
     	            LOG.info("This store {} can not provide a legend.", dataStore.getName(), e);
                     LOG.debug("This store {} does not provide a legend.",
                         dataStore.getName());
     			} catch (DynMethodException e) {
     				LOG.error("Can't load the specific legend provided for the store {}.", dataStore.getName(), e);
                     LOG.error(
                         "Can't load the specific legend provided for the store {}.",
                         dataStore.getName(), e);
+    			}
+    		}

     			// Registramos al FMap como listener del legend de las capas
     			FLayer lyr = e.getAffectedLayer();
     			selectionListener(lyr);
     			if (lyr instanceof SingleLayer){
     				if (((SingleLayer) lyr).getDataStore() != null) {
     					((SingleLayer) lyr).getDataStore().addObserver(
     							MapContext.this);
+    				}
+    			}
     			addSelectionListener(lyr);
+    		}
     		/**
     		 * <p>Registers an event buffer as a listener for all layers as argument.</p>
+    		 *
     		 * <p>Each {@link FLayer FLayer} of this map must have an event buffer for all kind
     		 * of specific listeners of that layer. This method distinguish between {@link Classifiable Classifiable},
     		 * {@link AlphanumericData AlphanumericData}, and {@link FLayers FLayers} layers, and for each one,
     		 * registers, for their specific listeners, the <code>eventBuffer</code> as a listener.</p>
+    		 *
     		 * @param the layer or layers
     		 */
     		private void selectionListener(FLayer lyr){
     			lyr.addLayerListener(eventBuffer);
     			if (lyr instanceof Classifiable) {
     				Classifiable c = (Classifiable) lyr;
     				c.addLegendListener(eventBuffer);
+    			}
     			if (lyr instanceof FLayers){
     				FLayers lyrs=(FLayers)lyr;
     				for(int i=0;i<lyrs.getLayersCount();i++){
     					selectionListener(lyrs.getLayer(i));
+    				}
+    			}
+    		}
     		/*
     		 * @see com.iver.cit.gvsig.fmap.layers.LayerCollectionListener#layerMoved(com.iver.cit.gvsig.fmap.layers.LayerPositionEvent)
     		 */
-...
     		layers.addLayerCollectionListener(eventBuffer);
     		layers.setProjection(vp.getProjection());
     		//Add the listener for the selection
     		addSelectionListener(layers);
+    	}
     	private void loadLayers(FLayers lyrs) {
-...
     		dispose(layers);
     		dispose(tracLayer);
+    	}
         /**
          * <p>Registers an event buffer as a listener for all layers as argument.</p>
+         *
          * <p>Each {@link FLayer FLayer} of this map must have an event buffer for all kind
          * of specific listeners of that layer. This method distinguish between {@link Classifiable Classifiable},
          * {@link AlphanumericData AlphanumericData}, and {@link FLayers FLayers} layers, and for each one,
          * registers, for their specific listeners, the <code>eventBuffer</code> as a listener.</p>
+         *
          * @param the layer or layers
          */
         private void addSelectionListener(FLayer lyr){
             lyr.addLayerListener(eventBuffer);
             if (lyr instanceof Classifiable) {
                 Classifiable c = (Classifiable) lyr;
                 c.addLegendListener(eventBuffer);
+            }
             if (lyr instanceof FLayers){
                 FLayers lyrs=(FLayers)lyr;
                 for(int i=0;i<lyrs.getLayersCount();i++){
                     addSelectionListener(lyrs.getLayer(i));
+                }
+            }
             if (lyr instanceof SingleLayer){
                 if (((SingleLayer) lyr).getDataStore() != null) {
                     ((SingleLayer) lyr).getDataStore().addObserver(
                             MapContext.this);
+                }
+            }
+        }
+    }

     import java.util.Collections;
     import java.util.HashMap;
     import java.util.Map;
     import java.util.Random;
     import org.gvsig.fmap.mapcontext.MapContextRuntimeException;
     import org.gvsig.fmap.mapcontext.impl.InvalidRegisteredClassException;
-...
     import org.gvsig.tools.persistence.PersistenceManager;
     import org.gvsig.tools.persistence.PersistentState;
     import org.gvsig.tools.persistence.exception.PersistenceException;
     import org.gvsig.tools.persistence.exception.PersistenceValidateExceptions;
     /**
      * Default {@link SymbolManager} implementation.
-...
     					symbolClass, symbolName, e);
+    		}
             Color symbolColor;
             if (getSymbolPreferences().isDefaultSymbolFillColorAleatory()) {
                 Random rand = new Random();
                 int numreg = rand.nextInt(255 / 2);
                 double div = (1 - rand.nextDouble() * 0.66) * 0.9;
                 symbolColor =
                     new Color(
                         ((int) (255 * div + (numreg * rand.nextDouble()))) % 255,
                         ((int) (255 * div + (numreg * rand.nextDouble()))) % 255,
                         ((int) (255 * div + (numreg * rand.nextDouble()))) % 255);
+            }
             else {
                 symbolColor = getSymbolPreferences().getDefaultSymbolFillColor();
+            }
             symbol.setColor(symbolColor);
     		// Perform this initialization into the Symbol implementation
     		// if (symbol instanceof CartographicSupport) {
     		// CartographicSupport cs = (CartographicSupport) symbol;

     				toCartographicSize(viewPort, doc.getDPI(), geom);
     				// draw it as normally
     				Geometry decimatedShape = transformToInts(geom, viewPort.getAffineTransform());
     				symbol.draw(g, viewPort.getAffineTransform(), decimatedShape,
     						doc.getFeature(), cancel);
     				//the AffineTransform has to be null because the transformToInts method
     				//reprojects the geometry
     				symbol.draw(g, null, decimatedShape, doc.getFeature(), cancel);
     				// restore previous size
     				((CartographicSupport)symbol).setCartographicSize(previousSize, geom);
     			}else{

| gvSIG desktop 1

Revision 37204