Application: gvSIG desktop

 *

 * Copyright (C) 2007-2013 gvSIG Association.

 *

 *

 *

 *

 */

package org.gvsig.fmap.mapcontext.layers.vectorial;

import org.gvsig.tools.persistence.PersistenceManager;

import org.gvsig.tools.persistence.PersistentState;

import org.gvsig.tools.persistence.exception.PersistenceException;

import org.gvsig.tools.task.Cancellable;

import org.gvsig.tools.util.Callable;

/**

 * Capa b?sica Vectorial.

 */

public class FLyrVect extends FLyrDefault implements VectorLayer,

    private IVectorLegend legend;

    private int typeShape = -1;

    private FeatureStore featureStore = null;

    public FLyrVect() {

        super();

    }

            return MapContextLocator.getMapContextManager().getIconLayer(this.getDataStore());

            return "layer-icon-unavailable";

    /**

     * Devuelve el VectorialAdapater de la capa.

     * @return VectorialAdapter.

     */

    public DataStore getDataStore() {

        }

        return featureStore;

    }

    /**

     * @param dataStore

     * @throws LoadLayerException

     * @deprecated use {@link #bindToDataStore(DataStore)}

     */

    public void setDataStore(DataStore dataStore) throws LoadLayerException {

    }

    /**

     * Enlaza la capa con el DataStore indicado.

     * @param dataStore

     * @throws LoadLayerException

     */

        featureStore = (FeatureStore) dataStore;

        //Set the legend

        if (legend == null) {

            throw new LegendLayerException(this.getName());

        this.setLegend(legend);

        //Set the labeling strategy

        if (labeler != null) {

            labeler.setLayer(this);

            this.setLabelingStrategy(labeler);

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

        }

        this.delegate(dataStore);

        // Esto es para cuando se crea una capa nueva con el fullExtent de ancho

        // y alto 0.

        if (rAux == null || rAux.isEmpty() || rAux.getMaximum(0) - rAux.getMinimum(0) == 0

            try {

            } catch (CreateEnvelopeException e) {

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

                e.printStackTrace();

        // Si existe reproyecci?n, reproyectar el extent

        ICoordTrans ct = getCoordTrans();

        if (ct != null) {

        }

        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

     * @throws ReadDriverException

     */

    public void draw(BufferedImage image,

        if (legend == null) {

            return;

        FeatureQuery featureQuery = null;

        try {

                featureQuery = getFeatureStore().createFeatureQuery();

                featureQuery.addFilter(intersectsTimeEvaluator);

            }

        } catch (DataException e1) {

        }

        try {

            long tini = System.currentTimeMillis();

            legend.draw(image,

        } catch (LegendException e) {

            this.setVisible(false);

            this.setActive(false);

    }

    public void print(Graphics2D g,

        if (!this.isWithinScale(scale)) {

            return;

        }

        try {

            legend.print(g,

        } catch (LegendException e) {

            this.setVisible(false);

            this.legend.addDrawingObserver(this);

            this.legend.addLegendListener(this);

        }

        e.setLayer(this);

        updateDrawVersion();

        callLegendChanged(e);

    /**

     * Devuelve la Leyenda de la capa.

     * @return Leyenda.

     */

    public ILegend getLegend() {

    }

    public int getShapeType() throws ReadException {

    }

    /**

     * Returns the layer's geometry type

     * @return the geometry type

     */

    public GeometryType getGeometryType() throws ReadException {

        FeatureType featureType = null;

        try {

            if (getDataStore() != null) {

            }

        } catch (DataException e) {

            throw new ReadException(getName(), e);

        }

        return featureType == null ? null : featureType

    }

    public void saveToState(PersistentState state) throws PersistenceException {

        FeatureStore featureStore = null;

            logger.info("The '" + this.getName() + "' layer is not available, it will persist not.");

            return;

        }

        try {

            super.saveToState(state);

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

            }

            featureStore = getFeatureStore();

                state.set("featureStore", featureStore);

            }

            state.set("isLabeled", isLabeled);

                state.set("labelingStrategy", strategy);

            }

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

            }

    }

    public void loadFromState(PersistentState state) throws PersistenceException {

        DataStore store = null;

        Boolean isLabeled = Boolean.FALSE;

        try {

            try {

                this.bindToDataStore(store);

            } catch (LoadLayerException e) {

            }

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

            try {

                throw new PersistenceException("Can't set vector legend to the layer.", e);

            }

            try {

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

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

                }

            } catch (Exception ex) {

                        ex);

            }

                this.setIsLabeled(true);

                this.setLabelingStrategy(labelingStrategy);

            } else {

            typeShape = state.getInt("typeShape");

        } catch (Throwable e) {

            this.setAvailable(false);

            return;

        }

    /**

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

     * identifiquen la capa.

     * @return DOCUMENT ME!

     */

    public String toString() {

            return fs.isEditing();

        }

    }

    public void setEditing(boolean b) throws StartEditionLayerException {

        try {

            throw new RuntimeException();

        } catch (Throwable th) {

            logger.info("This method is deprecated. ", th);

        }

        if (b == super.isEditing()) {

            return;

        }

        super.setEditing(b);

        FeatureStore fs = getFeatureStore();

        if (b) {

        callEditionChanged(LayerEvent.createEditionChangedEvent(this, "edition"));

    }

    /**

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

     */

    /**

     * Siempre es un numero mayor de 1000

     * @param maxFeatures

     */

    public void setMaxFeaturesInEditionCache(int maxFeatures) {

    }

    /**

     */

    public boolean isPropertiesMenuVisible() {

        return true;

    }

    protected boolean isOnePoint(AffineTransform graphicsTransform,

        return isOnePoint(graphicsTransform, viewPort, geom, xyCoords)

    }

    private boolean isOnePoint(AffineTransform graphicsTransform,

        boolean onePoint = false;

        int type = geom.getType();

        if (type == Geometry.TYPES.NULL) {

            Envelope geomBounds = geom.getEnvelope();

            // ICoordTrans ct = getCoordTrans();

            // Se supone que la geometria ya esta reproyectada

            // if (ct!=null) {

            // // geomBounds = ct.getInverted().convert(geomBounds);

            // geomBounds = geomBounds.convert(ct);

            // }

            double dist1Pixel = viewPort.getDist1pixel();

            if (onePoint) {

                // avoid out of range exceptions

                org.gvsig.fmap.geom.primitive.Point p;

                try {

                    p.transform(viewPort.getAffineTransform());

                    p.transform(graphicsTransform);

                    xyCoords[0] = (int) p.getX();

    }

    public void drawLabels(BufferedImage image,

        if (strategy != null && isWithinScale(scale)) {

            strategy.draw(image, g, scale, viewPort, cancel, dpi);

        }

    }

    public void printLabels(Graphics2D g,

        if (strategy != null) {

            strategy.print(g, scale, viewPort, cancel, properties);

        }

    /**

     * Return true, because a Vectorial Layer supports HyperLink

     * @deprecated the hiperlink functionaliti is out the layer now

     */

    public boolean allowLinks() {

    }

    /**

     */

    public FeatureSet queryByPoint(Point2D mapPoint,

        logger.warn("Deprecated use of queryByPoint.");

        GeometryManager manager = GeometryLocator.getGeometryManager();

        org.gvsig.fmap.geom.primitive.Point center;

        try {

            center.setX(mapPoint.getX());

            center.setY(mapPoint.getY());

            circle.setPoints(center, tol);

            return queryByGeometry(circle, featureType);

        } catch (org.gvsig.fmap.geom.exception.CreateGeometryException e) {

    }

    public FeatureSet queryByPoint(org.gvsig.fmap.geom.primitive.Point point,

        GeometryManager manager = GeometryLocator.getGeometryManager();

        try {

            circle.setPoints(point, tol);

            return queryByGeometry(circle, featureType);

        } catch (org.gvsig.fmap.geom.exception.CreateGeometryException e) {

    /**

     * Input geom must be in the CRS of the view.

     * @param geom

     * @param featureType

     * @return

     */

    public FeatureSet queryByGeometry(Geometry geom, FeatureType featureType) throws DataException {

        FeatureQuery featureQuery = featureStore.createFeatureQuery();

                .getDefaultGeometryAttributeName();

        featureQuery.setFeatureType(featureType);

        Geometry query_geo = this.transformToSourceCRS(geom, true);

        IProjection query_proj = getMapContext().getProjection();

        if (this.getCoordTrans() != null) {

        }

        featureQuery.setFilter(iee);

        featureQuery.setAttributeNames(null);

        return getFeatureStore().getFeatureSet(featureQuery);

    /**

     * It return the {@link FeatureSet} that intersects with the envelope.

     * @throws DataException

     */

    public FeatureSet queryByEnvelope(Envelope envelope, FeatureType featureType) throws DataException {

    /**

     * It return the {@link FeatureSet} that intersects with the envelope.

     * @throws DataException

     */

    public FeatureSet queryByEnvelope(Envelope envelope,

        FeatureQuery featureQuery = featureStore.createFeatureQuery();

        if (names == null) {

            featureQuery.setFeatureType(featureType);

        }

        String geomName = featureStore.getDefaultFeatureType()

                .getDefaultGeometryAttributeName();

        Envelope query_env = fromViewPortCRSToSourceCRS(this, envelope);

        IProjection query_proj = getMapContext().getProjection();

        if (this.getCoordTrans() != null) {

        }

        featureQuery.setFilter(iee);

        return getFeatureStore().getFeatureSet(featureQuery);

    }

    public DynObjectSet getInfo(Point p, double tolerance, Cancellable cancel) throws LoadLayerException,

        return getInfo(p, tolerance, cancel, true);

    }

    public DynObjectSet getInfo(Point p,

        Point2D infop = new Point2D.Double(p.x, p.y);

        Point2D pReal = this.getMapContext().getViewPort().toMapPoint(infop);

        return queryByPoint(pReal,

    }

    public DynObjectSet getInfo(org.gvsig.fmap.geom.primitive.Point p,

    }

    public void legendCleared(LegendClearEvent event) {

        this.updateDrawVersion();

        this.callLegendChanged(e);

    }

    public boolean symbolChanged(SymbolLegendEvent e) {

        this.updateDrawVersion();

        this.callLegendChanged(ev);

        return true;

    }

    public void update(Observable observable, Object notification) {

        if (observable.equals(this.featureStore)) {

            if (notification instanceof FeatureStoreNotification) {

                if (event.getType() == FeatureStoreNotification.AFTER_DELETE

                    this.updateDrawVersion();

                } else if (event.getType() == FeatureStoreNotification.AFTER_CANCELEDITING) {

                    setSpatialCacheEnabled(false);

                    callEditionChanged(LayerEvent.createEditionChangedEvent(this, "edition"));

                    this.updateDrawVersion();

                } else if (event.getType() == FeatureStoreNotification.AFTER_STARTEDITING) {

                    setSpatialCacheEnabled(true);

                    callEditionChanged(LayerEvent.createEditionChangedEvent(this, "edition"));

                    //If a transform has to be applied, try to reload the layer.

                    try {

                        reload();

                    }

                } else if (event.getType() == FeatureStoreNotification.RESOURCE_CHANGED) {

                    this.setAvailable(false);

                    this.setAvailable(true);

                    setSpatialCacheEnabled(false);

                    callEditionChanged(LayerEvent.createEditionChangedEvent(this, "edition"));

                    this.updateDrawVersion();

                }

            }

            // This code is needed in editing mode

            spatialCache.insert(geometry.getEnvelope(), geometry);

        }

    }

        } else {

            return this.getMapContext().getLayersToSnap().contains(this);

        }

     * (non-Javadoc)

     * 

     * @see org.gvsig.metadata.Metadata#getMetadataChildren()

     */

    public Object getMetadataID() throws MetadataException {

        return "Layer(" + this.getName() + "):"

    }

    public GeometryType getTypeVectorLayer() throws DataException,

        // FIXME Esto deberia de pedirse a FType!!!!

        FeatureStore fs = this.getFeatureStore();

        FeatureType fType = fs.getDefaultFeatureType();

                .getGeometryType(attr.getGeometryType(),

        return geomType;

    }

        dispose(featureStore);

        spatialCache.clearAll();

    }

    /**

     * @param lyr

     * @param env

     * @return

    }

    public Geometry transformToSourceCRS(Geometry geom, boolean clone) {

    }

    /**

     * @param lyr

     * @param geo

     * @param clone

     * @deprecated use the transformToSourceCRS method of layer.

     */

    public static Geometry fromViewPortCRSToSourceCRS(

        if (lyr == null || geo == null) {

            return null;

        }

        return resp;

    }

}