Application: gvSIG desktop

 *

 */

public class FLyrVect

    final static private org.slf4j.Logger logger

    private final GeometryManager geomManager

    /**

     * Leyenda de la capa vectorial

     * @throws LoadLayerException

     */

    protected void bindToDataStore(DataStore dataStore) throws LoadLayerException {

            this.featureStore.deleteObserver(this);

        }

        featureStore = (FeatureStore) dataStore;

        MapContextManager mapContextManager

        //Set the legend

        IVectorLegend legend

            throw new LegendLayerException(this.getName());

        }

        //Set the labeling strategy

        ILabelingStrategy labeler

            labeler.setLayer(this);

            this.setLabelingStrategy(labeler);

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

    public Envelope getFullEnvelope() throws ReadException {

        Envelope rAux;

            return null;

        }

        try {

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

        // y alto 0.

            try {

                rAux

            } catch (CreateEnvelopeException e) {

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

                e.printStackTrace();

        }

        // Si existe reproyecci?n, reproyectar el extent

        ICoordTrans ct = getCoordTrans();

            boolean originalEnvelopeIsEmpty = rAux.isEmpty();

            rAux = rAux.convert(ct);

                try {

                    this.setAvailable(false);

                    throw new EnvelopeCantBeInitializedException();

    }

    public void addBaseFilter(Evaluator filter) {

            this.baseQuery = this.getFeatureStore().createFeatureQuery();

        }

        this.baseQuery.addFilter(filter);

     * @throws ReadDriverException

     */

    public void draw(BufferedImage image,

            return;

        }

            return;

        }

            return;

        }

            spatialCache.clearAll();

            legend.addDrawingObserver(this);

        }

        try {

            FeatureAttributeDescriptor featureAttributeDescriptor

                IntersectsTimeEvaluator intersectsTimeEvaluator

                featureQuery.addFilter(intersectsTimeEvaluator);

            }

        } catch (DataException e1) {

            long tini = System.currentTimeMillis();

            legend.draw(image,

            logger.debug("Layer " + this.getName() + " drawn in "

        } catch (LegendException e) {

            this.setAvailable(false);

            this.setError(e);

            throw new ReadException(getName(), e);

        } finally {

                legend.deleteDrawingObserver(this);

            }

        }

    }

    public void print(Graphics2D g,

            return;

        }

            return;

        }

        FeatureQuery featureQuery = createFeatureQuery();

        try {

            legend.print(g,

        } catch (LegendException e) {

            this.setVisible(false);

    }

    public void setLegend(IVectorLegend legend) throws LegendLayerException {

            return;

        }

            return;

        }

        IVectorLegend oldLegend = this.legend;

        this.legend = legend;

            oldLegend.removeLegendListener(this);

            oldLegend.deleteDrawingObserver(this);

        }

            this.legend.addDrawingObserver(this);

            this.legend.addLegendListener(this);

        }

    }

    public int getShapeType() throws ReadException {

            FeatureType featureType = null;

            try {

                    featureType

                }

            } catch (DataException e) {

                throw new ReadException(getName(), e);

            }

                int indexGeom = featureType.getDefaultGeometryAttributeIndex();

                typeShape

            }

        }

        return typeShape;

    public GeometryType getGeometryType() throws ReadException {

        FeatureType featureType = null;

        try {

                featureType

            }

        } 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());

            }

            typeShape = state.getInt("typeShape", Geometry.TYPES.GEOMETRY);

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

                this.setAvailable(false);

                this.addError(new RuntimeException("Can't retrieve store information."));

            } else {

                    this.setAvailable(false);

                    this.addError(store.getBreakingsCause());

                }

            }

            try {

                    this.setIsLabeled(true);

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

                    this.setLabelingStrategy(labelingStrategy);

    public boolean isEditing() {

        FeatureStore fs = getFeatureStore();

            /*

             * This happens when layer is not available, for example,

             * it was not possible to load from persistence

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

        }

            return;

        }

        super.setEditing(b);

        FeatureStore fs = getFeatureStore();

            try {

                fs.edit();

            } catch (DataException e) {

     * @param maxFeatures

     */

    public void setMaxFeaturesInEditionCache(int maxFeatures) {

            spatialCache.setMaxFeatures(maxFeatures);

        }

    }

    protected void putLoadLegend() throws LegendLayerException {

            return;

        }

        this.setLegend(this.loadLegend);

        clonedLayer.setIsLabeled(isLabeled());

        ILabelingStrategy labelingStrategy = getLabelingStrategy();

            clonedLayer.setLabelingStrategy(labelingStrategy);

        }

    }

    protected boolean isOnePoint(AffineTransform graphicsTransform,

        return isOnePoint(graphicsTransform, viewPort, geom, xyCoords)

    }

    private boolean isOnePoint(AffineTransform graphicsTransform,

        boolean onePoint = false;

        int type = geom.getType();

            return false;

        }

            Envelope geomBounds = geom.getEnvelope();

            double dist1Pixel = viewPort.getDist1pixel();

            onePoint

                // avoid out of range exceptions

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

                try {

                    p

                    p.transform(viewPort.getAffineTransform());

                    p.transform(graphicsTransform);

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

    public void setLabelingStrategy(ILabelingStrategy strategy) {

        this.strategy = strategy;

            return;

        }

        strategy.setLayer(this);

    }

    public void drawLabels(BufferedImage image,

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

        }

    }

    public void printLabels(Graphics2D g,

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

        }

    }

    }

    public FeatureQuery createFeatureQuery() {

            return this.getFeatureStore().createFeatureQuery();

        }

        try {

     * {@link #queryByPoint(org.gvsig.fmap.geom.primitive.Point, double, FeatureType)}

     */

    public FeatureSet queryByPoint(Point2D mapPoint,

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

        GeometryManager manager = GeometryLocator.getGeometryManager();

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

        try {

            center

            center.setX(mapPoint.getX());

            center.setY(mapPoint.getY());

            Circle circle

            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 circle

            circle.setPoints(point, tol);

            return queryByGeometry(circle, featureType);

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

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

        IProjection query_proj = getMapContext().getProjection();

            query_proj = this.getCoordTrans().getPOrig();

        }

        Evaluator iee = SpatialEvaluatorsFactory.getInstance().intersects(

        );

        featureQuery.setFilter(iee);

        featureQuery.setAttributeNames(null);

     * @throws DataException

     */

    public FeatureSet queryByEnvelope(Envelope envelope,

        FeatureQuery featureQuery = createFeatureQuery();

            featureQuery.setFeatureType(featureType);

        } else {

            featureQuery.setAttributeNames(names);

        Envelope query_env = fromViewPortCRSToSourceCRS(this, envelope);

        IProjection query_proj = getMapContext().getProjection();

            query_proj = this.getCoordTrans().getPOrig();

        }

        Evaluator iee = SpatialEvaluatorsFactory.getInstance().intersects(

        );

        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,

        return queryByPoint(p, tolerance, getFeatureStore().getDefaultFeatureType()).getDynObjectSet(false);

    }

    }

    public void update(Observable observable, Object notification) {

                FeatureStoreNotification event

                    this.updateDrawVersion();

                    setSpatialCacheEnabled(false);

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

                    this.updateDrawVersion();

                    setSpatialCacheEnabled(true);

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

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

                    try {

                        reload();

                        logger.info("While reloading layer.", e);

                        this.setAvailable(false);

                    }

                    this.setAvailable(false);

                    this.setAvailable(true);

                    setSpatialCacheEnabled(false);

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

                    this.updateDrawVersion();

                }

            }

            // This code is needed in editing mode

            // for all layers involved in snapping

            // (including the layer being edited)

            Geometry geometry

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

        }

    }

    private boolean isLayerToSnap() {

            /*

             * This happens with the graphics layer because it has no parent

             */

     */

    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();

        FeatureAttributeDescriptor attr

        GeometryType geomType

        return geomType;

    }

    public static class RegisterPersistence

        public Object call() {

            PersistenceManager manager = ToolsLocator.getPersistenceManager();

            DynStruct definition

            definition.extend(PersistenceManager.PERSISTENCE_NAMESPACE,

            definition.addDynFieldObject("legend")

            definition.addDynFieldObject("featureStore")

            definition.addDynFieldBoolean("isLabeled").setMandatory(true);

            definition.addDynFieldInt("typeShape").setMandatory(true);

            definition.addDynFieldObject("labelingStrategy")

            return Boolean.TRUE;

        }

     */

    public static Envelope fromViewPortCRSToSourceCRS(FLayer lyr, Envelope env) {

            return null;

        }

        ICoordTrans ct = lyr.getCoordTrans();

            return env;

        } else {

            return env.convert(ct.getInverted());

     * @deprecated use the transformToSourceCRS method of layer.

     */

    public static Geometry fromViewPortCRSToSourceCRS(

            return null;

        }

        ICoordTrans ct = lyr.getCoordTrans();

        Geometry resp = geo;

            resp = resp.cloneGeometry();

        }

            resp.reProject(ct.getInverted());

        }

        return resp;

    }

    protected class EnvelopeCantBeInitializedException

        /**

         *

    public String getInfoString() {

        LayerInformationBuilder builder = MapContextLocator.getMapContextManager().createLayerInformationBuilder();

            builder.title().labelkey("Warning");

            builder.text().value("The layer is not available.");

        }

        Envelope env = null;

        FeatureAttributeDescriptor attrgeom = null;

        try {

            env = this.getFullEnvelope();

        } catch (Exception ex) {

        builder.title().labelkey("Data_source");

        builder.property().labelkey("Source_type").value(store.getProviderName());

        builder.property().labelkey("origen").value(store.getFullName());

            File f = ((FilesystemStoreParameters) (store.getParameters())).getFile();

                builder.property().labelkey("_Size").value("%d bytes", f.length());

            }

        }

            builder.property().labelkey("_Geometry_column").value(attrgeom.getName());

            builder.property().labelkey("_Geometry_type").value(attrgeom.getGeomType().getFullName());

        }

        builder.title().labelkey("_Coordenadas_geograficas");

            builder.envelope().value(env);

        }

        builder.title().labelkey("_Projection");

            builder.property().value(this.getProjection());

            builder.text().asWKT(this.getProjection());

        }

        return builder.toString();

    }

}