/ - Diff - | gvSIG desktop 1 - gvSIG

Revision 22281

     import com.iver.cit.gvsig.fmap.layers.layerOperations.LayerCollection;
     import com.iver.cit.gvsig.fmap.layers.layerOperations.VectorialData;
     import com.iver.cit.gvsig.fmap.layers.layerOperations.XMLItem;
     import com.iver.cit.gvsig.fmap.layers.order.DefaultOrderManager;
     import com.iver.cit.gvsig.fmap.layers.order.OrderManager;
     import com.iver.cit.gvsig.fmap.operations.strategies.FeatureVisitor;
     import com.iver.cit.gvsig.fmap.operations.strategies.VisitException;
     import com.iver.cit.gvsig.fmap.rendering.VectorialLegend;
-...
     	protected static Logger logger = Logger.getLogger(FLayers.class.getName());
     	/**
     	 * <p>Note: Don't access it directly, use {@link #getOrderManager()} instead.</p>
     	 * <p>When a new layer is added to this FLayers,
     	 * the order manager will decide the right position for the
     	 * layer.</p> <p>The orderManager will only be used when adding a layer,
     	 * so it will not affect to the collection order when the user modifies the
     	 * order.</p>
     	 */
     	private OrderManager orderManager = null;
     	/**
     	 * Default <code>FLayers</code> constructor.
+    	 *
     	 * @param fmap reference to the <code>MapContext</code> instance that contains this node of layers
-...
     	 * @see com.iver.cit.gvsig.fmap.layers.layerOperations.LayerCollection#addLayer(com.iver.cit.gvsig.fmap.layers.FLayer)
     	 */
     	public void addLayer(FLayer layer) {
     		addLayer(layers.size(), layer);
     		int position = getOrderManager().getPosition(this, layer);
     		addLayer(position, layer);
+    	}
     	/**
-...
     			if (layer instanceof FLayers){
     				FLayers layers=(FLayers)layer;
     				if (!layers.hasOrderManager()) {
     					layers.setOrderManager(getOrderManager());
+    				}
     				fmap.addAsCollectionListener(layers);
+    			}
     			callLayerAdding(LayerCollectionEvent.createLayerAddingEvent(layer));
-...
+    					}
+    				}
     				this.addLayer(layer);
     				this.addLayer(layers.size(), layer);
+    			}
     		} /*azabala-modificaciones en layerfactory-
     		catch (DriverException e) {
-...
     		String[] s = xml.getStringArrayProperty("LayerNames");
     		// try {
     		fmap.clearErrors();
     			for (int i = 0; i < numLayers; i++) {
     				this.addLayerFromXML(xml.getChild(i),s[i]);
+    			}
     		/* } catch (DriverException e) {
     			throw new XMLException(e);
     		} */
     		/*if (loadLayerException.getExceptions().size()>0){
     			throw loadLayerException;
     		}*/
     		for (int i = 0; i < numLayers; i++) {
     			this.addLayerFromXML(xml.getChild(i),s[i]);
+    		}
+    	}
     	/*
-...
+    		}
     		this.addLayer(layer);
     		this.addLayer(layers.size(), layer);
     		long t2 = System.currentTimeMillis();
     		logger.debug("layer: "+ layer.getName() +" loaded. " + (t2-t1) + " msecs.");
     		// Comprobar que la proyecci?n es la misma que la de FMap
-...
+            }
+    	}
     	/**
     	 * <p>Creates a new layer of the same class as the property <i>className</i> of the XML, after, adds the XML entity to that layer
     	 *  and loads the layer. Then, adds the layer to this collection of layers, and if there is a projection defined,
     	 *  inserts the transformation coordinates to the layer.</p>
+    	 *
     	 * <p>If the new layer is an instance of <code>FLyrVect</code>, and has a label field, creates a label layer on the layer.</p>
+    	 *
     	 * @param xml tree-node structure with information about layers
     	 * @param name name of the layer to add
     	 */
     	private void addLayerFromXMLNew(XMLEntity xml, String name) {
     		FLayer layer = null;
     		try {
     		String className = xml.getStringProperty("className");
     		if (className.equals((FLayers.class.getName()))){
     			layer = new FLayers(getMapContext(),this);
     		} else {
     //		 	Por compatibilidad
     			if (className.equals(FLyrVect.class.getName())) {
     				if (xml.contains("file")) {
     					layer = new FLayerFileVectorial();
     				} else if (xml.contains("db")) {
     					try {
     						layer = (FLayer)((ExtensionPoint)ExtensionPointsSingleton.getInstance().get("Layers")).create("com.iver.cit.gvsig.fmap.layers.FLayerJDBCVectorial");
     					} catch (Exception e) {
     						throw new XMLException(new Exception("No se tiene registrada la capa de tipo JDBC"));
+    					}
     					//className = FLayerJDBCVectorial.class.getName();
     				} else if (xml.contains("other")){
     					layer = new FLayerGenericVectorial();
     				} else {
     					throw new XMLException(new Exception("Capa vectorial de tipo no reconocido"));
+    				}
     //				Fin por compatibilidad
     			} else {
     				try {
     					layer = (FLayer)(((ExtensionPoint)ExtensionPointsSingleton.getInstance().get("Layers")).create(className));
     				} catch (Exception e) {
     					//puende que no este registrada como punto de extension
     					Class clase = Class.forName(className);
     					layer = (FLayer) clase.newInstance();
     					// FIXME: Hacemos algo aqui o dejamos que suba el error?
+    				}
+    			}
+    		}
     		layer.setXMLEntity(xml);
     		if (name != null) layer.setName(name);
     		try {
     			layer.load();
     		}catch (DriverIOException e) {
     			throw new XMLException(e);
+    		}
     		this.addLayer(layer);
     		logger.debug("layer: "+ layer.getName() +" loaded");
     		// Comprobar que la proyecci?n es la misma que la de FMap
             // Si no lo es, es una capa que est? reproyectada al vuelo
             IProjection proj = layer.getProjection();
             if ((proj != null))
                 if (proj != getMapContext().getProjection())
+                {
                     ICoordTrans ct = proj.getCT(getMapContext().getProjection());
                     // TODO: REVISAR CON LUIS
                     // Se lo fijamos a todas, luego cada una que se reproyecte
                     // si puede, o que no haga nada
                     layer.setCoordTrans(ct);
                     // NOTA: DESPU?S DE ESTO DEBER?AMOS CREAR LAS ETIQUETAS
                     // SI ES NECESARIO.
                     // TODO: REVISAR A FONDO ESTO, PORQUE LAS ETIQUETAS SE CREAN
                     // 2 VECES SI HAY REPROYECC?N
                     if (layer instanceof FLyrVect)
+                    {
                         FLyrVect lyrVect = (FLyrVect)layer;
                         VectorialLegend legend = (VectorialLegend) lyrVect.getLegend();
                         if (legend.getLabelField() != null) {
                             lyrVect.createLabelLayer(lyrVect.getRecordset());
+                        }
+                    }
+                }
             }catch (Exception e) {
             		fmap.addLayerError(xml.getStringProperty("name"));
     				//loadLayerException.addException(e);
     			/*if (layer!=null){
             	layer.setActive(false);
     			layer.setVisible(false);
     			this.addLayer(layer);
             	}*/
     			//throw new XMLException(e);
                 System.err.println("No se ha podido cargar la capa : "+xml.getStringProperty("name"));
                 logger.debug("No se ha podido cargar la capa : "+xml.getStringProperty("name") + ". Raz?n:");
                 // logger.debug(e.fillInStackTrace());
                 e.printStackTrace();
+            }
+    	}
     	/**
     	 * <p>Calls recursively to its layer children to tell them that the layer is going
     	 * to be removed from the view. Overwrites <code>FLyrDefault.removingThisLayer()</code>.</p>
-...
+    			}
+    		}
+    	}
     	public void setOrderManager(OrderManager manager) {
     		orderManager = manager;
     		// change also the OrderManager of children
     		for (int i=0; i<layers.size(); i++) {
     			if (layers.get(i) instanceof FLayers) {
     				FLayers layer = (FLayers) layers.get(i);
     				layer.setOrderManager(orderManager);
+    			}
+    		}
+    	}
     	public OrderManager getOrderManager() {
     		if (orderManager==null) {
     			orderManager = new DefaultOrderManager();
+    		}
     		return orderManager;
+    	}
     	private boolean hasOrderManager() {
     		return (orderManager!=null);
+    	}
+    }

     package com.iver.cit.gvsig.fmap.layers.order;
     import com.iver.cit.gvsig.fmap.layers.FLayer;
     import com.iver.cit.gvsig.fmap.layers.FLayers;
     import com.iver.utiles.IPersistance;
     import com.iver.utiles.extensionPoints.IExtensionBuilder;
     /**
      * <p>The classes implementing this interface will decide the right position
      * to add a new layer (FLayer) to a layer collection (FLayers) according with
      * its own criterion.</p>
      * <p>Some order managers may study the existing layers in the collection and
      * the new layer's type in order to apply its criterion.</p>
      * <p>For example, an OrderManager
      * may decide that VectorLayers should be placed over Raster Layers.
      * Another OrderManager may decide that a new layer is placed just
      * over the existing layers (this had always been the default gvSIG
      * behaviour).</p>
+     *
      * @author Cesar Martinez Izquierdo <cesar.martinez@iver.es>
+     *
      */
     public interface OrderManager extends IPersistance, Cloneable, IExtensionBuilder {
     	/**
     	 * <p>Gets the proposed position for the newLayer in the target layer
     	 * collection. The OrderManager will study the arrangement of the
     	 * target layer collection and will decide the right position for
     	 * the new layer, according to its own criterion.</p>
+    	 *
     	 * @param target The target collection to which <code>newLayer</code>
     	 * will be added
     	 * @param newLayer The layer to be inserted in the layer collection
+    	 *
     	 * @return The proposed position for the new layer
     	 */
     	public int getPosition(FLayers target, FLayer newLayer);
     	/**
     	 * <p>Gets the name. The name should identify the
     	 * policy followed by this OrderManager to sort the layers.</p>
+    	 *
     	 * @return The name of the OrderManager
     	 */
     	public String getName();
     	/**
     	 * <p>Gets the description. The description should be enough to get
     	 * an idea of the policy and features of this OrderManager.</p>
+    	 *
     	 * @return The description of the OrderManager
     	 */
     	public String getDescription();
     	/**
     	 * <p>Gets the code used to register this OrderManager
     	 * in the ExtensionPoint.</p>
+    	 *
     	 * @return The code used to register this orderManager in the
     	 * ExtensionPoint.
     	 */
     	public String getCode();
     	public Object clone();
+    }

     package com.iver.cit.gvsig.fmap.layers.order;
     import java.util.Map;
     import org.apache.log4j.Logger;
     import com.iver.cit.gvsig.fmap.MapContext;
     import com.iver.cit.gvsig.fmap.Messages;
     import com.iver.cit.gvsig.fmap.layers.FLayer;
     import com.iver.cit.gvsig.fmap.layers.FLayers;
     import com.iver.utiles.XMLEntity;
     import com.iver.utiles.extensionPoints.ExtensionPoint;
     import com.iver.utiles.extensionPoints.ExtensionPointsSingleton;
     /**
      * Implements the default gvSIG behaviour when adding a new layer
      * to a collection.
+     *
      * @author Cesar Martinez Izquierdo <cesar.martinez@iver.es>
+     *
      */
     public class DefaultOrderManager implements OrderManager {
     	protected static final String extensionPointName = "layer.order.manager";
     	protected static final String configuredManagerKey = "default.manager";
     	protected static final String name = "DefaultsOrderManager";
     	protected static final String description = "New_layers_are_always_placed_on_top.";
     	public int getPosition(FLayers target, FLayer newLayer) {
     		return target.getLayersCount();
+    	}
     	public static String getExtensionPointName() {
     		return extensionPointName;
+    	}
     	public static String getDefaultManagerKey() {
     		return configuredManagerKey;
+    	}
     	public String getClassName() {
     		return this.getClass().getName();
+    	}
     	public XMLEntity getXMLEntity() {
     		return null;
+    	}
     	public void setXMLEntity(XMLEntity xml) {
+    	}
     	public String getDescription() {
     		return Messages.getString(description);
+    	}
     	public String getName() {
     		return Messages.getString(name);
+    	}
     	public String toString() {
     		return getName();
+    	}
     	public String getCode() {
     		return getClassName();
+    	}
     	public Object clone() {
     		try {
     			return super.clone();
     		} catch (CloneNotSupportedException e) {}
     		return null;
+    	}
     	public Object create() {
     		return this;
+    	}
     	public Object create(Object[] args) {
     		return this;
+    	}
     	public Object create(Map args) {
     		return this;
+    	}
     	/**
     	 * Gets the default OrderManager, as configured in the extension point.
+    	 *
     	 * @return The default OrderManager, as configured in the extension point,
     	 * or null if no manager was configured.
     	 */
     	public static OrderManager getDefaultOrderManager(){
     		try {
     			ExtensionPoint ep =
     				(ExtensionPoint) ExtensionPointsSingleton.getInstance().
     				get(DefaultOrderManager.getExtensionPointName());
     			if (ep!=null) {
     				Object obj = ep.create(DefaultOrderManager.getDefaultManagerKey());
     				if (obj!=null) {
     					return (OrderManager) obj;
+    				}
+    			}
+    		}
     		catch (Exception ex) {
     			Logger.getLogger(MapContext.class).warn("Error getting default layer order manager", ex);
+    		}
     		// if something goes wrong, just return the fallback default order manager
     		return null;
+    	}
     	/**
     	 * Gets the OrderManager registered as <code>managerCode</code> in the
     	 * extension point.
+    	 *
     	 * @return the OrderManager registered as <code>managerCode</code> in the
     	 * extension point, or an instance of DefaultOrderManager if not found.
     	 */
     	public static OrderManager getOrderManager(String managerCode){
     		try {
     			ExtensionPoint ep =
     				(ExtensionPoint) ExtensionPointsSingleton.getInstance().
     				get(DefaultOrderManager.getExtensionPointName());
     			if (ep!=null) {
     				Object obj = ep.create(managerCode);
     				if (obj!=null) {
     					return (OrderManager) obj;
+    				}
+    			}
+    		}
     		catch (Exception ex) {
     			Logger.getLogger(MapContext.class).warn("Error getting default layer order manager", ex);
+    		}
     		// if something goes wrong, just return the fallback default order manager
     		return  new DefaultOrderManager();
+    	}
     	/**
     	 * Checks whether an OrderManager was configured as default in the
     	 * extension point.
+    	 *
     	 * @return <code>true</code> if there is a default OrderManager configured
     	 * in the extension point, or <code>false</code> otherwise.
     	 */
     	public static boolean existsDefaultOrderManager() {
     		try {
     			ExtensionPoint ep =
     				(ExtensionPoint) ExtensionPointsSingleton.getInstance().
     				get(DefaultOrderManager.getExtensionPointName());
     			if (ep!=null) {
     				Object obj = ep.create(DefaultOrderManager.getDefaultManagerKey());
     				if (obj!=null) {
     					return true;
+    				}
+    			}
+    		}
     		catch (Exception ex) {
     			Logger.getLogger(MapContext.class).warn("Error getting default layer order manager", ex);
+    		}
     		return false;
+    	}
     	/**
     	 * Sets as system default OrderManager the provided manager code.
     	 */
     	public static void setDefaultOrderManager(String code){
     		try {
     			ExtensionPoint ep =
     				(ExtensionPoint) ExtensionPointsSingleton.getInstance().
     				get(DefaultOrderManager.getExtensionPointName());
     			if (ep!=null) {
     				ep.addAlias(code, DefaultOrderManager.getDefaultManagerKey());
+    			}
+    		}
     		catch (Exception ex) {
     			Logger.getLogger(MapContext.class).warn("Error getting default layer order manager", ex);
+    		}
+    	}
+    }

     import javax.print.attribute.PrintRequestAttributeSet;
     import org.apache.log4j.Logger;
     import org.cresques.cts.ICoordTrans;
     import org.cresques.cts.IProjection;
     import org.cresques.geo.Projected;
     import com.iver.cit.gvsig.fmap.layers.CancelationException;
     import com.iver.cit.gvsig.fmap.layers.FLayer;
     import com.iver.cit.gvsig.fmap.layers.FLayers;
-...
     import com.iver.cit.gvsig.fmap.layers.layerOperations.AlphanumericData;
     import com.iver.cit.gvsig.fmap.layers.layerOperations.Classifiable;
     import com.iver.cit.gvsig.fmap.layers.layerOperations.Selectable;
     import com.iver.cit.gvsig.fmap.layers.order.DefaultOrderManager;
     import com.iver.cit.gvsig.fmap.layers.order.OrderManager;
     import com.iver.cit.gvsig.fmap.operations.strategies.SelectedZoomVisitor;
     import com.iver.cit.gvsig.fmap.operations.strategies.VisitException;
     import com.iver.utiles.XMLEntity;
     import com.iver.utiles.extensionPoints.ExtensionPoint;
     import com.iver.utiles.extensionPoints.ExtensionPointsSingleton;
     import com.iver.utiles.swing.threads.Cancellable;
     /**
-...
     	public static ArrayList AREAABBR=new ArrayList();
     	public static ArrayList AREATRANS2METER=new ArrayList();
     	/**
     	 * <p>Note: Don't access it directly, use {@link #getOrderManager()} instead.</p>
     	 * <p>When a new layer is added to this MapContext,
     	 * the order manager will decide the right position for the
     	 * layer.</p> <p>The orderManager will only be used when adding a layer,
     	 * so it will not affect to the collection order when the user modifies the
     	 * order.</p>
     	 */
     	private OrderManager orderManager = null;
     	static{
     		addAreaUnit("Kilometros","Km",true,1000);
     		addAreaUnit("Metros","m",true,1);
-...
     				throw new XMLException(e);
+    			}
+    		}
     		aux.setOrderManager((OrderManager)antLayers.getOrderManager().clone());
     		ret.layers = aux;
     		return ret;
-...
     		xml.putProperty("className", this.getClass().getName());
     		xml.addChild(viewPort.getXMLEntity());
     		xml.addChild(layers.getXMLEntity());
     		if (orderManager!=null) {
     			xml.putProperty(DefaultOrderManager.getExtensionPointName(), orderManager.getCode());
     			XMLEntity child = orderManager.getXMLEntity();
     			if (child!=null) {
     				child.putProperty("name", DefaultOrderManager.getExtensionPointName());
     				child.putProperty("code", orderManager.getCode());
     				xml.addChild(child);
+    			}
+    		}
     		return xml;
+    	}
-...
     		ViewPort vp = ViewPort.createFromXML(xml.getChild(0));
     		MapContext fmap = new MapContext(vp);
     		fmap.layers.setXMLEntity(xml.getChild(1));
     		// read the orderManager
     		String managerKey = null;
     		if (xml.contains(DefaultOrderManager.getExtensionPointName())){
     			managerKey = xml.getStringProperty(DefaultOrderManager.getExtensionPointName());
+    		}
     		// set if even if it's null, to ensure MapContext gets a valid Manager
     		fmap.setOrderManager(managerKey);
     		// process the rest of childs
     		for (int i=2; i<xml.getChildrenCount(); i++) {
     			XMLEntity child = xml.getChild(i);
     			if (child.contains("name")) {
     				if (child.getName().equals(DefaultOrderManager.getExtensionPointName())) {
     					// order manager config
     					fmap.getOrderManager().setXMLEntity(child);
+    				}
     				// else {} // other childs may be added here
+    			}
+    		}
     		return fmap;
+    	}
-...
     		if (getLayers().getLayersCount() > 0)
     			getLayers().moveTo(0,0);
+    	}
     	/**
     	 * <p>Sets the OrderManager. When a new layer is added to this MapContext,
     	 * the order manager will decide the right position for the
     	 * layer.</p> <p>The orderManager will only be used when adding a layer,
     	 * so it will not affect to the collection order when the user modifies the
     	 * order.</p>
     	 */
     	public void setOrderManager(OrderManager manager) {
     		this.orderManager = manager;
     		layers.setOrderManager(manager);
+    	}
     	/**
     	 * <p>Returns the OrderManager. When a new layer is added to this MapContext,
     	 * the order manager will decide the right position for the
     	 * layer.</p> <p>The orderManager will only be used when adding a layer,
     	 * so it will not affect to the collection order when the user modifies the
     	 * order.</p>
+    	 *
     	 * @return The order manager, or null if the OrderManager was not set.
     	 */
     	public OrderManager getOrderManager() {
     		return orderManager;
+    	}
     	/**
     	 * <p>Try to set the OrderManager corresponding to the provided code.
     	 * If there is no such OrderManager in the ExtensionPoint, then sets the
     	 * {@link DefaultOrderManager}.</p>
+    	 *
     	 * @param managerKey The code which was used to register the
     	 * OrderManager in the ExtensionPoint.
+    	 *
     	 * @see OrderManger
     	 * @see DefaultOrderManager
     	 */
     	public void setOrderManager(String managerKey) {
     		if (managerKey!=null) {
     			ExtensionPoint ep =
     				(ExtensionPoint) ExtensionPointsSingleton.getInstance().
     				get(DefaultOrderManager.getExtensionPointName());
     			if (ep!=null) {
     				Object obj;
     				try {
     					obj = ep.create(managerKey);
     					if (obj!=null && obj instanceof OrderManager) {
     						setOrderManager((OrderManager) obj);
     						return;
+    					}
+    				}
     				catch (InstantiationException e) {}
     				catch (IllegalAccessException e) {}
+    			}
+    		}
     		// if the configured manager is not found, create default one
     		setOrderManager(DefaultOrderManager.getDefaultOrderManager());
+    	}
+    }

Also available in: Unified diff