Application: gvSIG desktop

			// TODO Auto-generated catch block

			e.printStackTrace();

			return null;

				// TODO Auto-generated catch block

				e.printStackTrace();

				// TODO Auto-generated catch block

				e.printStackTrace();

				// TODO Auto-generated catch block

				e.printStackTrace();

				// TODO Auto-generated catch block

				e.printStackTrace();

 *

public class FLyrVect extends FLyrDefault implements VectorLayer, LegendContentsChangedListener,

Observer {

	final static private org.slf4j.Logger logger = LoggerFactory.getLogger(FLyrVect.class);

	private final GeometryManager geomManager = GeometryLocator.getGeometryManager();

	/** Leyenda de la capa vectorial */

	private IVectorLegend legend;

	private int typeShape = -1;

	private FeatureStore featureStore=null;

	private SpatialCache spatialCache = new SpatialCache();

	/**

	 * An implementation of gvSIG spatial index

	 */

	//    protected ISpatialIndex spatialIndex = null;

	private IVectorLegend loadLegend = null;

	private boolean isLabeled;

	protected ILabelingStrategy strategy;

	public FLyrVect() {

		super();

	}

	/**

	 * Devuelve el VectorialAdapater de la capa.

	 *

	 * @return VectorialAdapter.

	 */

	public DataStore getDataStore() {

		if (!this.isAvailable()) {

			return null;

		}

		return featureStore;

	}

	/**

	 * If we use a persistent spatial index associated with this layer, and the

	 * index is not intrisic to the layer (for example spatial databases) this

	 * method looks for existent spatial index, and loads it.

	 *

	 */

	//    private void loadSpatialIndex() {

	//        //FIXME: Al abrir el indice en fichero...

	//        //?C?mo lo liberamos? un metodo Layer.shutdown()

	//

	//

	//        ReadableVectorial source = getSource();

	//        //REVISAR QUE PASA CON LOS DRIVERS DXF, DGN, etc.

	//        //PUES SON VECTORIALFILEADAPTER

	//        if (!(source instanceof VectorialFileAdapter)) {

	//            // we are not interested in db adapters

	//            return;

	//        }

	//        VectorialDriver driver = source.getDriver();

	//        if (!(driver instanceof BoundedShapes)) {

	//            // we dont spatially index layers that are not bounded

	//            return;

	//        }

	//        File file = ((VectorialFileAdapter) source).getFile();

	//        String fileName = file.getAbsolutePath();

	//        File sptFile = new File(fileName + ".qix");

	//        if (!sptFile.exists() || (!(sptFile.length() > 0))) {

	//            // before to exit, look for it in temp path

	//            String tempPath = System.getProperty("java.io.tmpdir");

	//            fileName = tempPath + File.separator + sptFile.getName();

	//            sptFile = new File(fileName);

	//            // it doesnt exists, must to create

	//            if (!sptFile.exists() || (!(sptFile.length() > 0))) {

	//                return;

	//            }// if

	//        }// if

	//

	//        try {

	//            source.start();

	//            spatialIndex = new QuadtreeGt2(FileUtils.getFileWithoutExtension(sptFile),

	//                    "NM", source.getFullExtent(), source.getShapeCount(), false);

	//            source.setSpatialIndex(spatialIndex);

	//        } catch (SpatialIndexException e) {

	//            spatialIndex = null;

	//            e.printStackTrace();

	//            return;

	//        } catch (ReadDriverException e) {

	//            spatialIndex = null;

	//            e.printStackTrace();

	//            return;

	//        }

	//

	//    }

	/**

	 * Checks if it has associated an external spatial index

	 * (an spatial index file).

	 *

	 * It looks for it in main file path, or in temp system path.

	 * If main file is rivers.shp, it looks for a file called

	 * rivers.shp.qix.

	 * @return

	 */

	//    public boolean isExternallySpatiallyIndexed() {

	//        /*

	//         * FIXME (AZABALA): Independizar del tipo de fichero de ?ndice

	//          * con el que se trabaje (ahora mismo considera la extension .qix,

	//         * pero esto depender? del tipo de ?ndice)

	//         * */

	//        ReadableVectorial source = getSource();

	//        if (!(source instanceof VectorialFileAdapter)) {

	//            // we are not interested in db adapters.

	//            // think in non spatial dbs, like HSQLDB

	//            return false;

	//        }

	//        File file = ((VectorialFileAdapter) source).getFile();

	//        String fileName = file.getAbsolutePath();

	//        File sptFile = new File(fileName + ".qix");

	//        if (!sptFile.exists() || (!(sptFile.length() > 0))) {

	//            // before to exit, look for it in temp path

	//            // it doesnt exists, must to create

	//            String tempPath = System.getProperty("java.io.tmpdir");

	//            fileName = tempPath + File.separator + sptFile.getName();

	//            sptFile = new File(fileName);

	//            if (!sptFile.exists() || (!(sptFile.length() > 0))) {

	//                return false;

	//            }// if

	//        }// if

	//        return true;

	//    }

	/**

	 * Inserta el VectorialAdapter a la capa.

	 *

	 * @param va

	 *            VectorialAdapter.

	 *

	 * @deprecated esto deber?a se ser protected

	 */

  	public void setDataStore(DataStore dataStore) throws LoadLayerException {

		if (this.featureStore != null && this.featureStore != dataStore){

			this.featureStore.deleteObserver(this);

		}

		featureStore = (FeatureStore)dataStore;

		ILegend legend = MapContextLocator.getMapContextManager().getLegend(dataStore);

		if( legend == null ) {

			throw new LegendLayerException(this.getName());				

		}

		this.setLegend((IVectorLegend)legend);

		ILabelingStrategy labeler = null;

		try {

			labeler = (ILabelingStrategy) dataStore.invokeDynMethod(

					"getLabeling", null);

		} catch (DynMethodNotSupportedException e1) {

			labeler = null;

		} catch (DynMethodException e1) {

			logger.error("Can't load the specific lebeling strategy provided for the layer {}.", this.getName(), e1);

		}

		if (labeler != null) {

			labeler.setLayer(this);

			this.setLabelingStrategy(labeler);

			this.setIsLabeled(true); // TODO: ac? no s'hauria de detectar si t? etiquetes?????

		}

		this.delegate(dataStore);

		dataStore.addObserver(this);

 		// azabala: we check if this layer could have a file spatial index

		// and load it if it exists

		//        loadSpatialIndex();

	}

	public Envelope getFullEnvelope() throws ReadException {

		Envelope rAux;

		try {

			rAux = getFeatureStore().getEnvelope();

		} catch (BaseException e) {

			throw new ReadException(getName(),e);

		}

		//Esto es para cuando se crea una capa nueva con el fullExtent de ancho y alto 0.

		if (rAux == null || rAux.getMaximum(0)-rAux.getMinimum(0)==0 && rAux.getMaximum(1)-rAux.getMinimum(1)==0) {

			try {

				rAux= geomManager.createEnvelope(0,0,100,100, SUBTYPES.GEOM2D);

			} catch (CreateEnvelopeException e) {

				logger.error("Error creating the envelope", e);

				e.printStackTrace();

			}

		}

		// Si existe reproyecci?n, reproyectar el extent

		ICoordTrans ct = getCoordTrans();

		try{

			if (ct != null) {

				Point2D pt1 = new Point2D.Double(rAux.getMinimum(0), rAux.getMinimum(1));

				Point2D pt2 = new Point2D.Double(rAux.getMaximum(0), rAux.getMaximum(1));

				pt1 = ct.convert(pt1, null);

				pt2 = ct.convert(pt2, null);

				try {

					rAux = geomManager.createEnvelope(pt1.getX(),pt1.getY(),pt2.getX(),pt2.getY(), SUBTYPES.GEOM2D);

				} catch (CreateEnvelopeException e) {

					logger.error("Error creating the envelope", e);

					e.printStackTrace();

				}//new Rectangle2D.Double();

			}

		}catch (IllegalStateException e) {

			this.setAvailable(false);

			this.addError(new ReprojectLayerException(getName(), e));

		}

		return rAux;

	}

	/**

	 * Draws using IFeatureIterator. This method will replace the old draw(...) one.

	 * @autor jaume dominguez faus - jaume.dominguez@iver.es

	 * @param image

	 * @param g

	 * @param viewPort

	 * @param cancel

	 * @param scale

	 * @throws ReadDriverException

	 */

	public void draw(BufferedImage image, Graphics2D g, ViewPort viewPort,

			Cancellable cancel, double scale) throws ReadException {

		if (legend == null) {

			return;

		}

		if (!this.isWithinScale(scale)) {

			return;

		}

		if (cancel.isCanceled()) {

			return;

		}

		if (spatialCache.isEnabled()) {

			spatialCache.clearAll();

			legend.addDrawingObserver(this);

		}

		try {

			legend.draw(image, g, viewPort, cancel, scale, null,

					getCoordTrans(), getFeatureStore());

		} catch (LegendException e) {

			this.setVisible(false);

			this.setActive(false);

			throw new ReadException(getName(), e);

		} finally {

			if (spatialCache.isEnabled()) {

				legend.deleteDrawingObserver(this);

			}

		}

	}

	public void print(Graphics2D g, ViewPort viewPort, Cancellable cancel,

			double scale, PrintAttributes properties) throws ReadException {

		if (!this.isWithinScale(scale)) {

			return;

		}

		if (cancel.isCanceled()) {

			return;

		}

		try {

			legend.print( g, viewPort, cancel, scale, null,

					getCoordTrans(), getFeatureStore(), properties);

		} catch (LegendException e) {

			this.setVisible(false);

			this.setActive(false);

			throw new ReadException(getName(), e);

		}

	}

	/**

	 * <p>

	 * Creates an spatial index associated to this layer.

	 * The spatial index will used

	 * the native projection of the layer, so if the layer is reprojected, it will

	 * be ignored.

	 * </p>

	 * @param cancelMonitor instance of CancellableMonitorable that allows

	 * to monitor progress of spatial index creation, and cancel the process

	 */

	//    public void createSpatialIndex(CancellableMonitorable cancelMonitor){

	//         // FJP: ESTO HABR? QUE CAMBIARLO. PARA LAS CAPAS SECUENCIALES, TENDREMOS

	//        // QUE ACCEDER CON UN WHILE NEXT. (O mejorar lo de los FeatureVisitor

	//        // para que acepten recorrer sin geometria, solo con rectangulos.

	//

	//        //If this vectorial layer is based in a spatial database, the spatial

	//        //index is already implicit. We only will index file drivers

	//        ReadableVectorial va = getSource();

	//        //We must think in non spatial databases, like HSQLDB

	//        if(!(va instanceof VectorialFileAdapter)){

	//            return;

	//        }

	//        if (!(va.getDriver() instanceof BoundedShapes)) {

	//            return;

	//        }

	//        File file = ((VectorialFileAdapter) va).getFile();

	//        String fileName = file.getAbsolutePath();

	//        ISpatialIndex localCopy = null;

	//        try {

	//            va.start();

	//            localCopy = new QuadtreeGt2(fileName, "NM", va.getFullExtent(),

	//                    va.getShapeCount(), true);

	//

	//        } catch (SpatialIndexException e1) {

	//            // Probably we dont have writing permissions

	//            String directoryName = System.getProperty("java.io.tmpdir");

	//            File newFile = new File(directoryName +

	//                    File.separator +

	//                    file.getName());

	//            String newFileName = newFile.getName();

	//            try {

	//                localCopy = new QuadtreeGt2(newFileName, "NM", va.getFullExtent(),

	//                        va.getShapeCount(), true);

	//            } catch (SpatialIndexException e) {

	//                // if we cant build a file based spatial index, we'll build

	//                // a pure memory spatial index

	//                localCopy = new QuadtreeJts();

	//            } catch (ReadException e) {

	//                localCopy = new QuadtreeJts();

	//            }

	//

	//        } catch(Exception e){

	//            e.printStackTrace();

	//        }//try

	//        BoundedShapes shapeBounds = (BoundedShapes) va.getDriver();

	//        try {

	//            for (int i=0; i < va.getShapeCount(); i++)

	//            {

	//                if(cancelMonitor != null){

	//                    if(cancelMonitor.isCanceled())

	//                        return;

	//                    cancelMonitor.reportStep();

	//                }

	//                Rectangle2D r = shapeBounds.getShapeBounds(i);

	//                if(r != null)

	//                    localCopy.insert(r, i);

	//            } // for

	//            va.stop();

	//            if(localCopy instanceof IPersistentSpatialIndex)

	//                ((IPersistentSpatialIndex) localCopy).flush();

	//            spatialIndex = localCopy;

	//            //vectorial adapter needs a reference to the spatial index, to solve

	//            //request for feature iteration based in spatial queries

	//            source.setSpatialIndex(spatialIndex);

	//        } catch (ReadException e) {

	//            // TODO Auto-generated catch block

	//            e.printStackTrace();

	//        }

	//    }

	//    public void createSpatialIndex() {

	//        createSpatialIndex(null);

	//    }

	public void setLegend(IVectorLegend legend) throws LegendLayerException {

		if (this.legend == legend){

			return;

		}

		if (this.legend != null && this.legend.equals(legend)){

			return;

		}

		IVectorLegend oldLegend = this.legend;

		this.legend = legend;

		if (oldLegend != null) {

			oldLegend.removeLegendListener(this);

			oldLegend.deleteDrawingObserver(this);

		}

		if (legend != null) {

			this.legend.addDrawingObserver(this);

			this.legend.addLegendListener(this);

		}

		LegendChangedEvent e = LegendChangedEvent.createLegendChangedEvent(

				oldLegend, this.legend);

		e.setLayer(this);

		callLegendChanged(e);

	}

	/**

	 * Devuelve la Leyenda de la capa.

	 *

	 * @return Leyenda.

	 */

	public ILegend getLegend() {

		return legend;

	}

	/**

	 * Devuelve el tipo de shape que contiene la capa.

	 *

	 * @return tipo de shape.

	 *

	 * @throws ReadException

	 */

	public int getShapeType() throws ReadException {

		if (typeShape == -1) {

			FeatureType featureType;

			try {

				featureType = (((FeatureStore)getDataStore()).getDefaultFeatureType());

			} catch (DataException e) {

				throw new ReadException(getName(),e);

			}

			int indexGeom=featureType.getDefaultGeometryAttributeIndex();

			typeShape=featureType.getAttributeDescriptor(indexGeom).getGeometryType();

		}

		return typeShape;

	}

	public void saveToState(PersistentState state) throws PersistenceException {

		if (!this.isAvailable()) {

			return;

		}

		super.saveToState(state);

		if (getLegend()!=null) {

			state.set("legend", getLegend());

		}

		FeatureStore fst = null;

		fst = getFeatureStore();

		if (fst != null) {

			state.set("featureStore", fst);

		}

		state.set("isLabeled", isLabeled);

		if (strategy != null) {

			state.set("labelingStrategy", strategy);

		}		

		if (getLinkProperties() != null) {

			state.set("linkProperties", getLinkProperties());

		}

//		state.set("bHasJoin", bHasJoin);

		state.set("typeShape", typeShape);

	}

//	public XMLEntity getXMLEntity() throws XMLException {

//

//		if (!this.isAvailable() && this.orgXMLEntity != null) {

//			return this.orgXMLEntity;

//		}

//		XMLEntity xml = super.getXMLEntity();

//		if (getLegend()!=null){

//			XMLEntity xmlLegend=getLegend().getXMLEntity();

//			xmlLegend.putProperty("tagName","legend");

//			xml.addChild(xmlLegend);

//		}

//		try {

//			PersistenceManager manager = ToolsLocator.getPersistenceManager();

//			PersistentState stateFeatureStore=manager.getState(getFeatureStore());

//			stateFeatureStore.set("tagName","featureStore");

//			xml.addChild(((XMLEntityState)stateFeatureStore).getXMLEntity());

//		} catch (ReadException e) {

//			throw new XMLLayerException(getName(),e);

//		} catch (PersistenceException e) {

//			throw new XMLLayerException(getName(),e);

//		}

//		// properties from ILabelable

//		xml.putProperty("isLabeled", isLabeled);

//		if (strategy != null) {

//			XMLEntity strategyXML = strategy.getXMLEntity();

//			strategyXML.putProperty("tagName", "labelingStrategy");

//			xml.addChild(strategy.getXMLEntity());

//		}

//		xml.addChild(getLinkProperties().getXMLEntity());

//		return xml;

//	}

	public void loadFromState(PersistentState state) throws PersistenceException {

		super.loadFromState(state);

		DataStore store = (DataStore) state.get("featureStore");

		try {

			this.setDataStore(store);

		} catch (LoadLayerException e) {

			throw new PersistenceException("While loading FLyrVect from state.", e);

		}

		IVectorLegend lgnd = (IVectorLegend) state.get("legend");

		try {

			this.setLegend(lgnd);

		} catch (LegendLayerException e) {

			throw new PersistenceException("While loading FLyrVect from state.", e);

		}

		Boolean isLbl = new Boolean(false);

		ILabelingStrategy lblst = null;

		try {

			isLbl = (Boolean) state.get("isLabeled");

			if (isLbl.booleanValue()) {

				lblst = (ILabelingStrategy) state.get("labelingStrategy");

			}

		} catch (Exception ex) {

			throw new PersistenceException("While loading FLyrVect from state.", ex);

		}

		/*

		String _labelFieldName = null;

		String _labelfield = null;

		*/

		if (isLbl.booleanValue()) {

			this.setIsLabeled(true);

			this.setLabelingStrategy(lblst);

		} else {

			this.setIsLabeled(false);

			this.setLabelingStrategy(null);

		}

//		try {

//			linkProperties = (FLyrVectLinkProperties) state.get("linkProperties");

//		} catch (PersistenceException pex) {

//			// not mandatory

//			linkProperties = null;

//		}

		//bHasJoin = state.getBoolean("bHasJoin");

		typeShape = state.getInt("typeShape");

//			try { _labelFieldName = state.getString("labelFieldName"); } catch (PersistenceException ex) {

//				_labelFieldName = null;

//			}

//			try { _labelfield = state.getString("labelfield"); } catch (PersistenceException ex) {

//				_labelfield = null;

//			}

			// ILabelingStrategy not implemented

//			if (_labelFieldName != null) {

//				

//				AttrInTableLabelingStrategy labeling = new AttrInTableLabelingStrategy();

//				try {

//					labeling.setLayer(this);

//				} catch (ReadException e) {

//					logger.error("While setting layer to AttrInTableLabelingStrategy: " + e.getMessage());

//				}

//				labeling.setUsesFixedSize(true);

//				labeling.setFixedSize(10);

//				labeling.setTextField(_labelFieldName);

//				labeling.setHeightField(state.getString("labelHeightFieldName"));

//				labeling.setRotationField(state.getString("labelRotationFieldName"));

//				setLabelingStrategy(labeling);

//				setIsLabeled(true);

//				

//			} else {

//				if (_labelfield != null) {

//					

//					AttrInTableLabelingStrategy labeling = new AttrInTableLabelingStrategy();

//					try {

//						labeling.setLayer(this);

//					} catch (ReadException e) {

//						logger.error("While setting layer to AttrInTableLabelingStrategy: " + e.getMessage());

//					}

//					labeling.setUsesFixedSize(true);

//					labeling.setFixedSize(10);

//					labeling.setTextField(_labelfield);

//					labeling.setHeightField(state.getString("labelFieldHeight"));

//					labeling.setRotationField(state.getString("labelFieldRotation"));

//					setLabelingStrategy(labeling);

//					setIsLabeled(true);

//				}

//			}

	}

//	public void setXMLEntity(XMLEntity xml) throws XMLException {

//		try {

//			super.setXMLEntity(xml);

//			XMLEntity legendXML = xml.firstChild("tagName","legend");

//			IVectorLegend leg = LegendFactory.createFromXML(legendXML);

//

//			//    	PersistentState persistentState=new XMLEntityState(new XMLEntityManager());

//			XMLEntity xmlStore=xml.firstChild("tagName","featureStore");

//			XMLEntityManager xmlManger = new XMLEntityManager();

//			PersistentState state = xmlManger.createState(xmlStore);

//			DataStore store = (DataStore) ToolsLocator.getPersistenceManager().create(state);

//			//    	persistentState.createState(xmlStore);

//

//			//    	DataManager dm=DALLocator.getDataManager();

//

//			this.setDataStore(store);

//			/* end patch */

//			try {

//				setLegend(leg);

//			} catch (LegendLayerException e) {

//				throw new XMLLegendException(e);

//			}

//			// set properties for ILabelable

//

//			if (xml.contains("isLabeled")

//					&& xml.getBooleanProperty(("isLabeled"))) {

//				XMLEntity labelingXML = xml.firstChild("tagName", "labelingStrategy");

//				if (labelingXML != null){

//

//					isLabeled = true;

//					try {

//						this.strategy = LabelingFactory.createStrategyFromXML(labelingXML, this);

//					} catch (NotExistInXMLEntity neXMLEX) {

//						// no strategy was set, just continue;

//						logger.warn("Reached what should be unreachable code");

//					}

//				} else {

//					isLabeled = false;

//				}

//			} else if (legendXML.contains("labelFieldName")|| legendXML.contains("labelfield")) {

//    			/* (jaume) begin patch;

//        		 * for backward compatibility purposes. Since gvSIG v1.1 labeling is

//        		 * no longer managed by the Legend but by the ILabelingStrategy. The

//        		 * following allows restoring older projects' labelings.

//        		 */

//				String labelTextField =	null;

//    			if (legendXML.contains("labelFieldName")){

//    				labelTextField = legendXML.getStringProperty("labelFieldName");

//    				if (labelTextField != null) {

//    					AttrInTableLabelingStrategy labeling = new AttrInTableLabelingStrategy();

//    					labeling.setLayer(this);

//    					labeling.setUsesFixedSize(true);

//    					labeling.setFixedSize(10);

//    					labeling.setTextField(labelTextField);

//    					labeling.setHeightField(legendXML.getStringProperty("labelHeightFieldName"));

//    					labeling.setRotationField(legendXML.getStringProperty("labelRotationFieldName"));

//    					this.setLabelingStrategy(labeling);

//    					this.setIsLabeled(true);

//    				}

//    			}else{

//    				labelTextField = legendXML.getStringProperty("labelfield");

//    				if (labelTextField != null) {

//    					AttrInTableLabelingStrategy labeling = new AttrInTableLabelingStrategy();

//    					labeling.setLayer(this);

//    					labeling.setUsesFixedSize(true);

//    					labeling.setFixedSize(10);

//    					labeling.setTextField(labelTextField);

//    					labeling.setHeightField(legendXML.getStringProperty("labelFieldHeight"));

//    					labeling.setRotationField(legendXML.getStringProperty("labelFieldRotation"));

//    					this.setLabelingStrategy(labeling);

//    					this.setIsLabeled(true);

//    				}

//    			}

//        	}else{

//				isLabeled = false;

//			}

//			XMLEntity xmlLinkProperties=xml.firstChild("typeChild","linkProperties");

//			if (xmlLinkProperties != null){

//				getLinkProperties().setXMLEntity(xmlLinkProperties);

//			}

//		} catch (Exception e) {

//			e.printStackTrace();

//			this.setAvailable(false);

//			this.orgXMLEntity = xml;

//

//		}

//		//

//

//	}

	/**

	 * Sobreimplementaci?n del m?todo toString para que las bases de datos

	 * identifiquen la capa.

	 *

	 * @return DOCUMENT ME!

	 */

	public String toString() {

		/*

		 * Se usa internamente para que la parte de datos identifique de forma

		 * un?voca las tablas

		 */

		String ret = super.toString();

		return "layer" + ret.substring(ret.indexOf('@') + 1);

	}

//	public boolean isJoined() {

//		return bHasJoin;

//	}

	/**

	 * Returns if a layer is spatially indexed

	 *

	 * @return if this layer has the ability to proces spatial queries without

	 *         secuential scans.

	 */

	//    public boolean isSpatiallyIndexed() {

	//        ReadableVectorial source = getSource();

	//        if (source instanceof ISpatialDB)

	//            return true;

	//

	////FIXME azabala

	///*

	// * Esto es muy dudoso, y puede cambiar.

	// * Estoy diciendo que las que no son fichero o no son

	// * BoundedShapes estan indexadas. Esto es mentira, pero

	// * as? quien pregunte no querr? generar el indice.

	// * Esta por ver si interesa generar el indice para capas

	// * HSQLDB, WFS, etc.

	// */

	//        if(!(source instanceof VectorialFileAdapter)){

	//            return true;

	//        }

	//        if (!(source.getDriver() instanceof BoundedShapes)) {

	//            return true;

	//        }

	//

	//        if (getISpatialIndex() != null)

	//            return true;

	//        return false;

	//    }

//

//	public void setIsJoined(boolean hasJoin) {

//		bHasJoin = hasJoin;

//	}

	//    /**

	//     * @return Returns the spatialIndex.

	//     */

	//    public ISpatialIndex getISpatialIndex() {

	//        return spatialIndex;

	//    }

	//    /**

	//     * Sets the spatial index. This could be useful if, for some

	//     * reasons, you want to work with a distinct spatial index

	//     * (for example, a spatial index which could makes nearest

	//     * neighbour querys)

	//     * @param spatialIndex

	//     */

	//    public void setISpatialIndex(ISpatialIndex spatialIndex){

	//        this.spatialIndex = spatialIndex;

	//    }

	public void setEditing(boolean b) throws StartEditionLayerException {

		super.setEditing(b);

		if (b){

			try {

				getFeatureStore().edit();

			} catch (ReadException e) {

				throw new StartEditionLayerException(getName(),e);

			} catch (DataException e) {

				throw new StartEditionLayerException(getName(),e);

			}

		}

		setSpatialCacheEnabled(b);

		callEditionChanged(LayerEvent

				.createEditionChangedEvent(this, "edition"));

	}

	/**

	 * @deprecated Use {@link #getSpatialCache()}

	 */

	public void clearSpatialCache()

	{

		spatialCache.clearAll();

	}

	/**

	 * @deprecated Use {@link #getSpatialCache()}

	 */

	public boolean isSpatialCacheEnabled() {

		return spatialCache.isEnabled();

	}

	/**

	 * @deprecated Use {@link #getSpatialCache()}

	 */

	public void setSpatialCacheEnabled(boolean spatialCacheEnabled) {

		spatialCache.setEnabled(spatialCacheEnabled);

	}

	public SpatialCache getSpatialCache() {

		return spatialCache;

	}

	/**

	 * Siempre es un numero mayor de 1000

	 * @param maxFeatures

	 */

	public void setMaxFeaturesInEditionCache(int maxFeatures) {

		if (maxFeatures > spatialCache.getMaxFeatures()) {

			spatialCache.setMaxFeatures(maxFeatures);

		}

	}

	/**

	 * This method returns a boolean that is used by the FPopMenu

	 * to make visible the properties menu or not. It is visible by

	 * default, and if a later don't have to show this menu only

	 * has to override this method.

	 * @return

	 * If the properties menu is visible (or not)

	 */

	public boolean isPropertiesMenuVisible(){

		return true;

	}

	public void reload() throws ReloadLayerException {

		super.reload();

		try {

			DataManager dataManager=DALLocator.getDataManager();

			DataStoreParameters storeParameters;

			storeParameters = getFeatureStore().getParameters();

			DataStore dataStore=dataManager.createStore(storeParameters);

			setDataStore(dataStore);