Application: gvSIG desktop

IVectorLegend {

    public static final String VECTORIAL_LEGEND_PERSISTENCE_DEFINITION_NAME = "VectorialLegend";

    private static final String FIELD_HAS_ZSORT = "hasZSort";

    private static final String FIELD_SHAPETYPE = "shapeType";

    private static final String FIELD_DEFAULT_SYMBOL = "defaultSymbol";

    private static final GeometryManager geomManager = GeometryLocator

    .getGeometryManager();

    protected ZSort zSort;

    public ZSort getZSort() {

        return zSort;

    }

    public void setZSort(ZSort zSort) {

        if (zSort == null) {

            removeLegendListener(this.zSort);

        }

        this.zSort = zSort;

        addLegendListener(zSort);

    }

    @SuppressWarnings("unchecked")

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

        Cancellable cancel, double scale, Map queryParameters,

        ICoordTrans coordTrans, FeatureStore featureStore)

    throws LegendException {

        double dpi = MapContext.getScreenDPI();

        draw(image, g, viewPort, cancel, scale, queryParameters, coordTrans,

            featureStore, null, dpi);

    }

    @SuppressWarnings("unchecked")

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

        Cancellable cancel, double scale, Map queryParameters,

        ICoordTrans coordTrans, FeatureStore featureStore, FeatureQuery featureQuery)

    throws LegendException {

        double dpi = MapContext.getScreenDPI();

        draw(image, g, viewPort, cancel, scale, queryParameters, coordTrans,

            featureStore, featureQuery, dpi);

    }

    @SuppressWarnings("unchecked")

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

        double scale, Map queryParameters, ICoordTrans coordTrans,

        FeatureStore featureStore, PrintAttributes properties)

    throws LegendException {

        print(g, viewPort, cancel, scale, queryParameters, coordTrans,

            featureStore, null, properties);

    }

    @SuppressWarnings("unchecked")

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

        double scale, Map queryParameters, ICoordTrans coordTrans,

        FeatureStore featureStore, FeatureQuery featureQuery, PrintAttributes properties)

    throws LegendException {

        double dpi = 72;

        int resolution = properties.getPrintQuality();

        if (resolution == PrintAttributes.PRINT_QUALITY_NORMAL) {

            dpi = 300;

        } else if (resolution == PrintAttributes.PRINT_QUALITY_HIGH) {

            dpi = 600;

        } else if (resolution == PrintAttributes.PRINT_QUALITY_DRAFT) {

            dpi = 72;

        }

        FeatureSet featureSet = null;

        DisposableIterator it = null;

        try {

            ZSort zSort = getZSort();

            // if layer has map levels it will use a ZSort

            boolean useZSort = zSort != null && zSort.isUsingZSort();

            int mapLevelCount = (useZSort) ? zSort.getLevelCount() : 1;

            for (int mapPass = 0; mapPass < mapLevelCount; mapPass++) {

                // Get the iterator over the visible features

                String[] fieldNames = getRequiredFeatureAttributeNames(featureStore);

                if (featureQuery == null){

                    featureQuery = featureStore.createFeatureQuery();

                }

                featureQuery.setAttributeNames(fieldNames);

                featureQuery.setScale(scale);

                ContainsEnvelopeEvaluator iee = new ContainsEnvelopeEvaluator(

                    viewPort.getAdjustedEnvelope(),

                    viewPort.getProjection(),

                    featureStore.getDefaultFeatureType(), featureStore

                    .getDefaultFeatureType()

                    .getDefaultGeometryAttributeName());

                featureQuery.addFilter(iee); 

                featureSet = featureStore.getFeatureSet(featureQuery);

                it = featureSet.fastIterator();

                // Iteration over each feature

                while (!cancel.isCanceled() && it.hasNext()) {

                    Feature feat = (Feature) it.next();

                    Geometry geom = feat.getDefaultGeometry();

                    // retrieve the symbol associated to such feature

                    ISymbol sym = getSymbolByFeature(feat);

                    if (sym == null) {

                        continue;

                    }

                    if (useZSort) {

                        int[] symLevels = zSort.getLevels(sym);

                        if (symLevels != null) {

                            // Check if this symbol is a multilayer

                            if (sym instanceof IMultiLayerSymbol) {

                                // if so, get the layer corresponding to the

                                // current level. If none, continue to next

                                // iteration

                                IMultiLayerSymbol mlSym = (IMultiLayerSymbol) sym;

                                for (int i = 0; i < mlSym.getLayerCount(); i++) {

                                    ISymbol mySym = mlSym.getLayer(i);

                                    if (symLevels[i] == mapPass) {

                                        sym = mySym;

                                        break;

                                    }

                                }

                            } else {

                                // else, just draw the symbol in its level

                                if (symLevels[0] != mapPass) {

                                    continue;

                                }

                            }

                        }

                    }

                    // Check if this symbol is sized with CartographicSupport

                    CartographicSupport csSym = null;

                    int symbolType = sym.getSymbolType();

                    if (symbolType == Geometry.TYPES.POINT

                        || symbolType == Geometry.TYPES.CURVE

                        || sym instanceof CartographicSupport) {

                        csSym = (CartographicSupport) sym;

                    }

                    DrawOperationContext doc = new DrawOperationContext();

                    doc.setGraphics(g);

                    doc.setViewPort(viewPort);

                    if (csSym == null) {

                        doc.setSymbol(sym);

                    } else {

                        doc.setDPI(dpi);

                        doc.setCancellable(cancel);

                        doc.setSymbol((ISymbol) csSym);

                    }

                    geom.invokeOperation(DrawInts.CODE, doc);

                }

            }

        } catch (ReadException e) {

            throw new LegendDrawingException(e);

        } catch (GeometryOperationNotSupportedException e) {

            throw new LegendDrawingException(e);

        } catch (GeometryOperationException e) {

            throw new LegendDrawingException(e);

        } catch (DataException e) {

            throw new LegendDrawingException(e);

        } catch (MapContextException e) {

            throw new LegendDrawingException(e);

        } finally {

            if (it != null) {

                it.dispose();

            }

            if (featureSet != null) {

                featureSet.dispose();

            }

        }

    }

    /**

     * Draws the features from the {@link FeatureStore}, filtered with the scale

     * and the query parameters, with the symbols of the legend.

     */

    @SuppressWarnings("unchecked")

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

        Cancellable cancel, double scale, Map queryParameters,

        ICoordTrans coordTrans, FeatureStore featureStore, FeatureQuery featureQuery, double dpi)

    throws LegendException {

        SimpleTaskStatus taskStatus = null;

        try {

            taskStatus = ToolsLocator.getTaskStatusManager()

            .creteDefaultSimpleTaskStatus(featureStore.getName());

            taskStatus.add();

            if (!getDefaultSymbol().isShapeVisible()) {

                return;

            }

            if (cancel.isCanceled()) {

                return;

            }

            IProjection dataProjection;

            Envelope reprojectedDataEnvelop;

            try {

                if (coordTrans == null) {

                    dataProjection = featureStore.getDefaultFeatureType()

                    .getDefaultSRS();

                    // If the data does not provide a projection, use the

                    // current

                    // view one

                    if (dataProjection == null) {

                        dataProjection = viewPort.getProjection();

                    }

                    reprojectedDataEnvelop = featureStore.getEnvelope();

                } else {

                    dataProjection = coordTrans.getPOrig();

                    reprojectedDataEnvelop = featureStore.getEnvelope()

                    .convert(coordTrans);

                }

            } catch (DataException e) {

                throw new LegendDrawingException(e);

            }

            // Gets the view envelope

            Envelope viewPortEnvelope = viewPort.getAdjustedEnvelope();

            // Gets the data envelope with the viewport SRS

            Envelope myEnvelope = reprojectedDataEnvelop;

            // TODO: in some cases, the legend may need a different check to

            // decide if the data must be drawn or not

            // Checks if the viewport envelope intersects with the data envelope

            if (!viewPortEnvelope.intersects(myEnvelope)) {

                // The data is not visible in the current viewport, do nothing.

                return;

            }

            // Check if all the data is contained into the viewport envelope

            boolean containsAll = viewPortEnvelope.contains(myEnvelope);

            // Create the drawing notification to be reused on each iteration

            DefaultFeatureDrawnNotification drawnNotification = new DefaultFeatureDrawnNotification();

            if (cancel.isCanceled()) {

                return;

            }

            FeatureSet featureSet = null;

            try {

                taskStatus.message("Retrieve selection");

                FeatureSelection selection = featureStore.getFeatureSelection();

                if (featureQuery == null){

                    featureQuery = featureStore.createFeatureQuery();

                }

                completeQuery(featureStore, featureQuery, scale,

                    queryParameters, coordTrans, dataProjection,

                    viewPortEnvelope, containsAll);

                taskStatus.message("Retrieve data");

                featureSet = featureStore.getFeatureSet(featureQuery);

                if (cancel.isCanceled()) {

                    return;

                }

                taskStatus.message("Drawing");

                drawFeatures(image, g, viewPort, cancel, coordTrans, dpi,

                    drawnNotification, featureSet, selection);

            } catch (BaseException e) {

                throw new LegendDrawingException(e);

            } finally {

                if (featureSet != null) {

                    featureSet.dispose();

                }

            }

        } finally {

            if (taskStatus != null) {

                taskStatus.terminate();

                taskStatus.remove();

                taskStatus = null;

            }

        }

    }

    /**

     * Complete a {@link FeatureQuery} to load the {@link Feature}s to draw.

     */

    @SuppressWarnings("unchecked")

    private FeatureQuery completeQuery(FeatureStore featureStore, FeatureQuery featureQuery, double scale,

        Map queryParameters, ICoordTrans coordTrans,

        IProjection dataProjection, Envelope viewPortEnvelope,

        boolean containsAll) throws DataException {

        featureQuery.setScale(scale);

        //Adds the attributes

        String[] fieldNames = getRequiredFeatureAttributeNames(featureStore);

        for (int i=0 ; i<fieldNames.length ;i++){

            featureQuery.addAttributeName(fieldNames[i]);

        }       

        // TODO: Mobile has it's own IntersectsEnvelopeEvaluator

        if (!containsAll) {

            // Gets the viewport envelope with the data SRS

            Envelope viewPortEnvelopeInMyProj = viewPortEnvelope;

            // FIXME

            if (coordTrans != null) {

                viewPortEnvelopeInMyProj = viewPortEnvelope.convert(coordTrans

                    .getInverted());

            }

            if (dataProjection == null) {

                throw new IllegalArgumentException(

                "Error, the projection parameter value is null");

            }

            IntersectsEnvelopeEvaluator iee = new IntersectsEnvelopeEvaluator(

                viewPortEnvelopeInMyProj, dataProjection,

                featureStore.getDefaultFeatureType(), featureStore

                .getDefaultFeatureType()

                .getDefaultGeometryAttributeName());

            featureQuery.addFilter(iee);			

        }

        if (queryParameters != null) {

            Iterator iterEntry = queryParameters.entrySet().iterator();

            Entry entry;

            while (iterEntry.hasNext()) {

                entry = (Entry) iterEntry.next();

                featureQuery.setQueryParameter((String) entry.getKey(),

                    entry.getValue());

            }

        }	

        return featureQuery;

    }

    /**

     * Draws the features from the {@link FeatureSet}, with the symbols of the

     * legend.

     */

    private void drawFeatures(BufferedImage image, Graphics2D g,

        ViewPort viewPort, Cancellable cancel, ICoordTrans coordTrans,

        double dpi, DefaultFeatureDrawnNotification drawnNotification,

        FeatureSet featureSet, FeatureSelection selection)

    throws BaseException {

        if (isUseZSort()) {

            drawFeaturesMultiLayer(image, g, viewPort, cancel, coordTrans, dpi,

                drawnNotification, featureSet, selection);

        } else {

            drawFeaturesSingleLayer(image, g, viewPort, cancel, coordTrans,

                dpi, drawnNotification, featureSet, selection);

        }

    }

    /**

     * Draws the features from the {@link FeatureSet}, with the symbols of the

     * legend, using a single drawing layer.

     */

    private void drawFeaturesSingleLayer(final BufferedImage image,

        final Graphics2D g, final ViewPort viewPort,

        final Cancellable cancel, final ICoordTrans coordTrans,

        final double dpi,

        final DefaultFeatureDrawnNotification drawnNotification,

        FeatureSet featureSet, final FeatureSelection selection)

    throws BaseException {

        try {

            featureSet.accept(new Visitor() {

                public void visit(Object obj) throws VisitCanceledException,

                BaseException {

                    Feature feat = (Feature) obj;

                    drawFeatureSingleLayer(image, g, viewPort, cancel,

                        coordTrans, dpi, drawnNotification, feat, selection);

                }

            });

        } catch (ConcurrentDataModificationException e) {

            cancel.setCanceled(true);

            return;

        }

    }

    /**

     * Draws a Feature with the symbols of the legend, using a single drawing

     * layer.

     */

    private void drawFeatureSingleLayer(BufferedImage image, Graphics2D g,

        ViewPort viewPort, Cancellable cancel, ICoordTrans coordTrans,

        double dpi, DefaultFeatureDrawnNotification drawnNotification,

        Feature feat, FeatureSelection selection)

    throws MapContextException, CreateGeometryException {

        Geometry geom = feat.getDefaultGeometry();

        if (geom == null) {

            return;

        }

        if (geom.getType() == Geometry.TYPES.NULL) {

            return;

        }

        ISymbol sym = getSymbol(feat, selection);

        if (sym == null) {

            return;

        }

        if (coordTrans != null) {

            geom = geom.cloneGeometry();

            geom.reProject(coordTrans);

        }

        if (cancel.isCanceled()) {

            return;

        }

        drawGeometry(geom, image, feat, sym, viewPort, g, dpi, cancel);

        // Notify the drawing observers

        drawnNotification.setFeature(feat);

        drawnNotification.setDrawnGeometry(geom);

        notifyObservers(drawnNotification);

    }

    /**

     * Draws the features from the {@link FeatureSet}, with the symbols of the

     * legend, using a multiple drawing layer.

     */

    private void drawFeaturesMultiLayer(BufferedImage image, Graphics2D g,

        ViewPort viewPort, Cancellable cancel, ICoordTrans coordTrans,

        double dpi, DefaultFeatureDrawnNotification drawnNotification,

        FeatureSet featureSet, FeatureSelection selection)

    throws MapContextException, CreateGeometryException, DataException {

        // -- visual FX stuff

        long time = System.currentTimeMillis();

        boolean bSymbolLevelError = false;

        // render temporary map each screenRefreshRate milliseconds;

        int screenRefreshDelay = (int) ((1D / MapContext.getDrawFrameRate()) * 3 * 1000);

        BufferedImage[] imageLevels = null;

        Graphics2D[] graphics = null;

        imageLevels = new BufferedImage[getZSort().getLevelCount()];

        graphics = new Graphics2D[imageLevels.length];

        for (int i = 0; !cancel.isCanceled() && i < imageLevels.length; i++) {

            imageLevels[i] = CompatLocator.getGraphicsUtils()

            .createBufferedImage(image.getWidth(), image.getHeight(),

                image.getType());

            graphics[i] = imageLevels[i].createGraphics();

            graphics[i].setTransform(g.getTransform());

            graphics[i].setRenderingHints(g.getRenderingHints());

        }

        // -- end visual FX stuff

        DisposableIterator it = null;

        try {

            it = featureSet.fastIterator();

            // Iteration over each feature

            while (it.hasNext()) {

                if (cancel.isCanceled()) {

                    return;

                }

                Feature feat = (Feature) it.next();

                bSymbolLevelError |= drawFeatureMultiLayer(image, g, viewPort,

                    cancel, coordTrans, dpi, drawnNotification, selection,

                    time, screenRefreshDelay, imageLevels, graphics, feat);

            }

        } catch (ConcurrentDataModificationException e) {

            cancel.setCanceled(true);

            return;

        } finally {

            if (it != null) {

                it.dispose();

            }

        }

        g.drawImage(image, 0, 0, null);

        Point2D offset = viewPort.getOffset();

        CompatLocator.getGraphicsUtils().translate(g, offset.getX(),

            offset.getY());

        for (int i = 0; !cancel.isCanceled() && i < imageLevels.length; i++) {

            g.drawImage(imageLevels[i], 0, 0, null);

            imageLevels[i] = null;

            graphics[i] = null;

        }

        CompatLocator.getGraphicsUtils().translate(g, -offset.getX(),

            -offset.getY());

        imageLevels = null;

        graphics = null;

        if (bSymbolLevelError) {

            setZSort(null);

        }

    }

    /**

     * Draws a Feature with the symbols of the legend, using a multiple drawing

     * layer.

     */

    private boolean drawFeatureMultiLayer(BufferedImage image, Graphics2D g,

        ViewPort viewPort, Cancellable cancel, ICoordTrans coordTrans,

        double dpi, DefaultFeatureDrawnNotification drawnNotification,

        FeatureSelection selection, long time, int screenRefreshDelay,

        BufferedImage[] imageLevels, Graphics2D[] graphics, Feature feat)

    throws MapContextException, CreateGeometryException {

        Geometry geom = feat.getDefaultGeometry();

        boolean bSymbolLevelError = false;

        long drawingTime = time;

        if (geom.getType() == Geometry.TYPES.NULL) {

            return false;

        }

        ISymbol sym = getSymbol(feat, selection);

        if (sym == null) {

            return false;

        }

        if (coordTrans != null) {

            geom = geom.cloneGeometry();

            geom.reProject(coordTrans);

        }

        if (cancel.isCanceled()) {

            return false;

        }

        // Check if this symbol is a multilayer

        int[] symLevels = getZSort().getLevels(sym);

        if (sym instanceof IMultiLayerSymbol) {

            // if so, treat each of its layers as a single

            // symbol

            // in its corresponding map level

            IMultiLayerSymbol mlSym = (IMultiLayerSymbol) sym;

            for (int i = 0; !cancel.isCanceled() && i < mlSym.getLayerCount(); i++) {

                ISymbol mySym = mlSym.getLayer(i);

                int symbolLevel = 0;

                if (symLevels != null) {

                    symbolLevel = symLevels[i];

                } else {

                    /*

                     * an error occured when managing symbol levels some of the

                     * legend changed events regarding the symbols did not

                     * finish satisfactory and the legend is now inconsistent.

                     * For this drawing, it will finish as it was at the bottom

                     * (level 0) but, when done, the ZSort will be reset to

                     * avoid app crashes. This is a bug that has to be fixed.

                     */

                    bSymbolLevelError = true;

                }

                drawGeometry(geom, imageLevels[symbolLevel], feat, mySym,

                    viewPort, graphics[symbolLevel], dpi, cancel);

            }

        } else {

            // else, just draw the symbol in its level

            int symbolLevel = 0;

            if (symLevels != null) {

                symbolLevel = symLevels[0];

            }

            drawGeometry(geom, imageLevels[symbolLevel], feat, sym, viewPort,

                graphics[symbolLevel], dpi, cancel);

        }

        // -- visual FX stuff

        // Cuando el offset!=0 se est? dibujando sobre el

        // Layout y por tanto no tiene que ejecutar el

        // siguiente c?digo.

        Point2D offset = viewPort.getOffset();

        if (offset.getX() == 0 && offset.getY() == 0) {

            if ((System.currentTimeMillis() - drawingTime) > screenRefreshDelay) {

                BufferedImage virtualBim = CompatLocator.getGraphicsUtils()

                .createBufferedImage(image.getWidth(),

                    image.getHeight(), BufferedImage.TYPE_INT_ARGB);

                Graphics2D virtualGraphics = virtualBim.createGraphics();

                virtualGraphics.drawImage(image, 0, 0, null);

                for (int i = 0; !cancel.isCanceled() && i < imageLevels.length; i++) {

                    virtualGraphics.drawImage(imageLevels[i], 0, 0, null);

                }

                g.clearRect(0, 0, image.getWidth(), image.getHeight());

                g.drawImage(virtualBim, 0, 0, null);

                drawingTime = System.currentTimeMillis();

            }

            // -- end visual FX stuff

        }

        // Notify the drawing observers

        drawnNotification.setFeature(feat);

        drawnNotification.setDrawnGeometry(geom);

        notifyObservers(drawnNotification);

        return bSymbolLevelError;

    }

    /**

     * Returns the symbol to use to draw a {@link Feature} taking into account

     * if it is selected.

     */

    private ISymbol getSymbol(Feature feat, FeatureSelection selection)

    throws MapContextException {

        // retrieve the symbol associated to such feature

        ISymbol sym = getSymbolByFeature(feat);

        if (sym != null && selection.isSelected(feat)) {

            sym = sym.getSymbolForSelection();

        }

        return sym;

    }

    /**

     * Returns if the legend is using a ZSort.

     */

    private boolean isUseZSort() {

        return getZSort() != null && getZSort().isUsingZSort();

    }

    /**

     * Draws a {@link Geometry} using the given {@link ISymbol}, over the

     * {@link Graphics2D} object.

     */

    private void drawGeometry(Geometry geom, BufferedImage image,

        Feature feature, ISymbol symbol, ViewPort viewPort,

        Graphics2D graphics, double dpi, Cancellable cancellable)

    throws CreateGeometryException {

        if (geom instanceof Aggregate) {

            drawAggregate((Aggregate) geom, image, feature, symbol, viewPort,

                graphics, dpi, cancellable);

        } else {

            boolean bDrawCartographicSupport = false;

            if (symbol instanceof CartographicSupport) {

                bDrawCartographicSupport = ((CartographicSupport) symbol)

                .getUnit() != -1;

            }

            double previousSize = 0.0d;

            if (bDrawCartographicSupport) {

                // make the symbol to resize itself with the current rendering

                // context

                previousSize = ((CartographicSupport) symbol)

                .toCartographicSize(viewPort, dpi, geom);

            }

            try {

                // draw it as normally

                double[] dot = new double[2];

                boolean onePoint = symbol.isOneDotOrPixel(geom, dot, viewPort,

                    (int) dpi);

                if (onePoint) {

                    if (dot[0] < 0 || dot[1] < 0 || dot[0] >= image.getWidth()

                        || dot[1] >= image.getHeight()) {

                        return;

                    }

                    // FIXME: setRgb should change to draw

                    image.setRGB((int) dot[0], (int) dot[1],

                        symbol.getOnePointRgb());

                } else {

                    Geometry decimatedShape = transformToInts(geom,

                        viewPort.getAffineTransform());

                    symbol.draw(graphics, viewPort.getAffineTransform(),

                        decimatedShape, feature, cancellable);

                }

            } finally {

                if (bDrawCartographicSupport) {

                    // restore previous size

                    ((CartographicSupport) symbol).setCartographicSize(

                        previousSize, geom);

                }

            }

        }

    }

    /**

     * Draws an {@link Aggregate} using the given {@link ISymbol}, over the

     * {@link Graphics2D} object.

     */

    private void drawAggregate(Aggregate aggregate, BufferedImage image,

        Feature feature, ISymbol symbol, ViewPort viewPort,

        Graphics2D graphics, double dpi, Cancellable cancellable)

    throws CreateGeometryException {

        for (int i = 0; i < aggregate.getPrimitivesNumber(); i++) {

            Geometry prim = aggregate.getPrimitiveAt(i);

            drawGeometry(prim, image, feature, symbol, viewPort, graphics, dpi,

                cancellable);

        }

    }

    /**

     * Transforms a Geometry from map coordinates to the view coordinates.

     */

    private Geometry transformToInts(Geometry gp, AffineTransform at)

    throws CreateGeometryException {

        GeometryOperationContext geometryOperationContext = new GeometryOperationContext();

        geometryOperationContext.setAttribute(ToIntsGeometryOperation.PARAM, at);

        try {

            throw new CreateGeometryException(gp.getType(), gp.getGeometryType().getSubType(), e);

    }

    public Object clone() throws CloneNotSupportedException {

        AbstractVectorialLegend clone = (AbstractVectorialLegend) super.clone();

        // Clone zSort

        ZSort zSort = getZSort();

        if (zSort != null) {

            clone.setZSort(new ZSort(clone));

        }

        return clone;

    }

    public void loadFromState(PersistentState state)

    throws PersistenceException {

        // Set parent properties

        super.loadFromState(state);

        // Set own properties

        setShapeType(state.getInt(FIELD_SHAPETYPE));

        if (state.getBoolean(FIELD_HAS_ZSORT)) {

            setZSort(new ZSort(this));

        }

        setDefaultSymbol((ISymbol) state.get(FIELD_DEFAULT_SYMBOL));

    }

    public void saveToState(PersistentState state) throws PersistenceException {

        // Save parent properties

        super.saveToState(state);

        // Save own properties

        state.set(FIELD_SHAPETYPE, getShapeType());

        state.set(FIELD_HAS_ZSORT, this.zSort != null);

        state.set(FIELD_DEFAULT_SYMBOL, getDefaultSymbol());

    }

    public static class RegisterPersistence implements Callable {

        public Object call() throws Exception {

            PersistenceManager manager = ToolsLocator.getPersistenceManager();

            if (manager

                .getDefinition(VECTORIAL_LEGEND_PERSISTENCE_DEFINITION_NAME) == null) {

                DynStruct definition = manager.addDefinition(

                    AbstractVectorialLegend.class,

                    VECTORIAL_LEGEND_PERSISTENCE_DEFINITION_NAME,

                    VECTORIAL_LEGEND_PERSISTENCE_DEFINITION_NAME

                    + " persistence definition", null, null);

                // Extend the Legend base definition

                definition.extend(manager

                    .getDefinition(LEGEND_PERSISTENCE_DEFINITION_NAME));

                // Shapetype

                definition.addDynFieldInt(FIELD_SHAPETYPE).setMandatory(true);

                // ZSort

                definition.addDynFieldBoolean(FIELD_HAS_ZSORT).setMandatory(

                    true);

                // Default symbol

                definition.addDynFieldObject(FIELD_DEFAULT_SYMBOL)

                .setClassOfValue(ISymbol.class).setMandatory(true);

            }

            return Boolean.TRUE;

        }

    }

    /**

     * Returns the names of the {@link Feature} attributes required for the

     * {@link ILegend} to operate.

     * 

     * @param featureStore

     *            the store where the {@link Feature}s belong to

     * @return the names of required {@link Feature} attribute names

     * @throws DataException

     *             if there is an error getting the attribute names

     */

    protected abstract String[] getRequiredFeatureAttributeNames(

        FeatureStore featureStore) throws DataException;

import org.gvsig.fmap.dal.feature.FeatureQuery;

AbstractLibraryAutoInitTestCase {

    private DefaultMapContextManager manager;

    protected void doSetUp() throws Exception {