Application: gvSIG desktop

				fullEnvelope.add(envelope);

    	fullEnvelope = originalEnvelope.getGeometry().getEnvelope();

							size = feature.getDouble(heightPos);

							color = new Color(feature.getInt(colorPos));

							if (feature.get(colorPos) != null) {

						rotation = -Math.toRadians(((Number) feature.get(rotationPos)).doubleValue());

    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, 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 {

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

                FeatureQuery featureQuery =

                    createQuery(featureStore, 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;

            }

        }

    }

    /**

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

            }

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