| gvSIG desktop 1

/* gvSIG. Geographic Information System of the Valencian Government

 *

 * Copyright (C) 2007-2008 Infrastructures and Transports Department

 * of the Valencian Government (CIT)

 * 

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 2

 * of the License, or (at your option) any later version.

 * 

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 * 

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, 

 * MA  02110-1301, USA.

 * 

 */

/*

 * AUTHORS (In addition to CIT):

 * 2009 {DiSiD Technologies}  {{Task}}

 */

package org.gvsig.symbology.fmap.mapcontext.rendering.legend.impl;

import java.awt.Graphics2D;

import java.awt.geom.AffineTransform;

import java.awt.geom.PathIterator;

import java.awt.geom.Point2D;

import java.awt.image.BufferedImage;

import java.util.Iterator;

import java.util.Map;

import java.util.Map.Entry;

import org.cresques.cts.ICoordTrans;

import org.cresques.cts.IProjection;

import org.gvsig.compat.CompatLocator;

import org.gvsig.compat.print.PrintAttributes;

import org.gvsig.fmap.dal.exception.DataException;

import org.gvsig.fmap.dal.exception.ReadException;

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

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

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

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

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

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

import org.gvsig.fmap.dal.feature.exception.ConcurrentDataModificationException;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryManager;

import org.gvsig.fmap.geom.Geometry.SUBTYPES;

import org.gvsig.fmap.geom.aggregate.Aggregate;

import org.gvsig.fmap.geom.exception.CreateGeometryException;

import org.gvsig.fmap.geom.operation.DrawInts;

import org.gvsig.fmap.geom.operation.DrawOperationContext;

import org.gvsig.fmap.geom.operation.GeometryOperationException;

import org.gvsig.fmap.geom.operation.GeometryOperationNotSupportedException;

import org.gvsig.fmap.geom.primitive.Envelope;

import org.gvsig.fmap.geom.primitive.GeneralPathX;

import org.gvsig.fmap.mapcontext.MapContext;

import org.gvsig.fmap.mapcontext.MapContextException;

import org.gvsig.fmap.mapcontext.ViewPort;

import org.gvsig.fmap.mapcontext.layers.vectorial.ContainsEnvelopeEvaluator;

import org.gvsig.fmap.mapcontext.layers.vectorial.IntersectsEnvelopeEvaluator;

import org.gvsig.fmap.mapcontext.rendering.legend.ILegend;

import org.gvsig.fmap.mapcontext.rendering.legend.IVectorLegend;

import org.gvsig.fmap.mapcontext.rendering.legend.LegendException;

import org.gvsig.fmap.mapcontext.rendering.legend.ZSort;

import org.gvsig.fmap.mapcontext.rendering.symbols.CartographicSupport;

import org.gvsig.fmap.mapcontext.rendering.symbols.IMultiLayerSymbol;

import org.gvsig.fmap.mapcontext.rendering.symbols.ISymbol;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DynClass;

import org.gvsig.tools.exception.BaseException;

import org.gvsig.tools.persistence.PersistentState;

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

import org.gvsig.tools.task.Cancellable;

import org.gvsig.tools.visitor.VisitCanceledException;

import org.gvsig.tools.visitor.Visitor;

/**

 * Base implementation for Vectorial data Legends.

 * 

 * Provides a draw method implementation which loads the {@link Feature}s and

 * uses the {@link ISymbol} objects to draw the {@link Geometry} objects.

 * 

 * @author 2009- <a href="cordinyana@gvsig.org">C?sar Ordi?ana</a> - gvSIG team

 */

public abstract class AbstractVectorialLegend extends AbstractLegend implements

                IVectorLegend {

        public static final String VECTORIAL_LEGEND_DYNCLASS_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, dpi);

        }

        @SuppressWarnings("unchecked")

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

                        double scale, Map queryParameters, ICoordTrans coordTrans,

                        FeatureStore featureStore, 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);

                                FeatureQuery featureQuery = featureStore.createFeatureQuery();

                                featureQuery.setAttributeNames(fieldNames);

                                featureQuery.setScale(scale);

                                ContainsEnvelopeEvaluator iee =

                                                new ContainsEnvelopeEvaluator(

                                                                viewPort.getAdjustedEnvelope(),

                                                                viewPort.getProjection(),

                                                                featureStore.getDefaultFeatureType(),

                                                                featureStore.getDefaultFeatureType()

                                                                                .getDefaultGeometryAttributeName());

                                featureQuery.setFilter(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, double dpi)

                        throws LegendException {

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

                        return;

                }

                if (cancel.isCanceled()) {

                        return;

                }

                IProjection dataProjection;

                Envelope reprojectedDataEnvelop;

                try {

                        if (coordTrans == null) {

                                dataProjection =

                                                featureStore.getDefaultFeatureType().getDefaultSRS();

                                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 {

                        FeatureSelection selection = featureStore.getFeatureSelection();

                        FeatureQuery featureQuery =

                                        createQuery(featureStore, scale, queryParameters,

                                                        coordTrans, dataProjection, viewPortEnvelope,

                                                        containsAll);

                        featureSet = featureStore.getFeatureSet(featureQuery);

                        if (cancel.isCanceled()) {

                                return;

                        }

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

                                        drawnNotification, featureSet, selection);

                } catch (BaseException e) {

                        throw new LegendDrawingException(e);

                } finally {

                        if (featureSet != null) {

                                featureSet.dispose();

                        }

                }

        }

        /**

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

         */

        @SuppressWarnings("unchecked")

        private FeatureQuery createQuery(FeatureStore featureStore, double scale,

                        Map queryParameters, ICoordTrans coordTrans,

                        IProjection dataProjection, Envelope viewPortEnvelope,

                        boolean containsAll) throws DataException {

                FeatureQuery featureQuery = featureStore.createFeatureQuery();

                featureQuery.setScale(scale);

                String[] fieldNames =

                        getRequiredFeatureAttributeNames(featureStore);

                featureQuery.setAttributeNames(fieldNames);

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

                        }

                        IntersectsEnvelopeEvaluator iee =

                                        new IntersectsEnvelopeEvaluator(viewPortEnvelopeInMyProj,

                                                        dataProjection,

                                                        featureStore.getDefaultFeatureType(),

                                                        featureStore.getDefaultFeatureType()

                                                                        .getDefaultGeometryAttributeName());

                        featureQuery.setFilter(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.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 {

                GeneralPathX newGp = new GeneralPathX();

                double[] theData = new double[6];

                double[] aux = new double[6];

                // newGp.reset();

                PathIterator theIterator;

                int theType;

                int numParts = 0;

                java.awt.geom.Point2D ptDst = new java.awt.geom.Point2D.Double();

                java.awt.geom.Point2D ptSrc = new java.awt.geom.Point2D.Double();

                boolean bFirst = true;

                int xInt, yInt, antX = -1, antY = -1;

                theIterator = gp.getPathIterator(null); // , flatness);

                int numSegmentsAdded = 0;

                while (!theIterator.isDone()) {

                        theType = theIterator.currentSegment(theData);

                        switch (theType) {

                        case PathIterator.SEG_MOVETO:

                                numParts++;

                                ptSrc.setLocation(theData[0], theData[1]);

                                at.transform(ptSrc, ptDst);

                                antX = (int) ptDst.getX();

                                antY = (int) ptDst.getY();

                                newGp.moveTo(antX, antY);

                                numSegmentsAdded++;

                                bFirst = true;

                                break;

                        case PathIterator.SEG_LINETO:

                                ptSrc.setLocation(theData[0], theData[1]);

                                at.transform(ptSrc, ptDst);

                                xInt = (int) ptDst.getX();

                                yInt = (int) ptDst.getY();

                                if ((bFirst) || ((xInt != antX) || (yInt != antY))) {

                                        newGp.lineTo(xInt, yInt);

                                        antX = xInt;

                                        antY = yInt;

                                        bFirst = false;

                                        numSegmentsAdded++;

                                }

                                break;

                        case PathIterator.SEG_QUADTO:

                                at.transform(theData, 0, aux, 0, 2);

                                newGp.quadTo(aux[0], aux[1], aux[2], aux[3]);

                                numSegmentsAdded++;

                                break;

                        case PathIterator.SEG_CUBICTO:

                                at.transform(theData, 0, aux, 0, 3);

                                newGp.curveTo(aux[0], aux[1], aux[2], aux[3], aux[4], aux[5]);

                                numSegmentsAdded++;

                                break;

                        case PathIterator.SEG_CLOSE:

                                if (numSegmentsAdded < 3) {

                                        newGp.lineTo(antX, antY);

                                }

                                newGp.closePath();

                                break;

                        } // end switch

                        theIterator.next();

                } // end while loop

                Geometry geom = null;

                switch (gp.getType()) {

                case Geometry.TYPES.POINT:

                        geom =

                                        geomManager.createPoint(ptDst.getX(), ptDst.getY(),

                                                        SUBTYPES.GEOM2D);

                        break;

                case Geometry.TYPES.CURVE:

                case Geometry.TYPES.ARC:

                        geom = geomManager.createCurve(newGp, SUBTYPES.GEOM2D);

                        break;

                case Geometry.TYPES.SURFACE:

                case Geometry.TYPES.CIRCLE:

                case Geometry.TYPES.ELLIPSE:

                        geom = geomManager.createSurface(newGp, SUBTYPES.GEOM2D);

                        break;

                }

                return geom;

        }

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

                if (getZSort() != null) {

                        state.set(FIELD_HAS_ZSORT, true);

                }

                if (getDefaultSymbol() != null) {

                        state.set(FIELD_DEFAULT_SYMBOL, getDefaultSymbol());

                }

        }

        /**

         * Registers the legend dynClass definition.

         */

        public static void registerPersistence() {

                // Add the DynClass definition.

                DynClass dynClass =

                                ToolsLocator.getDynObjectManager().add(

                                                VECTORIAL_LEGEND_DYNCLASS_NAME);

                // Extend the Legend base definition

                dynClass.extend(LEGEND_DYNCLASS_NAME);

                // Shapetype

                dynClass.addDynFieldInt(FIELD_SHAPETYPE);

                // ZSort

                dynClass.addDynFieldBoolean(FIELD_HAS_ZSORT);

                // Default symbol

                dynClass.addDynFieldObject(FIELD_DEFAULT_SYMBOL);

        }

        /**

         * 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;

}