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

 * 

 */

package org.gvsig.editing.gui.cad;

import java.awt.event.MouseEvent;

import java.awt.geom.AffineTransform;

import java.awt.geom.Point2D;

import java.util.ArrayList;

import org.cresques.cts.ICoordTrans;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.gvsig.andami.PluginServices;

import org.gvsig.andami.messages.NotificationManager;

import org.gvsig.andami.ui.mdiManager.IWindow;

import org.gvsig.app.project.documents.view.gui.DefaultViewPanel;

import org.gvsig.editing.CADExtension;

import org.gvsig.editing.gui.cad.exception.CommandException;

import org.gvsig.editing.layers.VectorialLayerEdited;

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

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

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

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

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

import org.gvsig.fmap.geom.Geometry;

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

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

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryManager;

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

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

import org.gvsig.fmap.geom.handler.Handler;

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

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

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

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

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

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

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

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

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

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

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

import org.gvsig.fmap.geom.util.UtilFunctions;

import org.gvsig.fmap.mapcontext.MapContextLocator;

import org.gvsig.fmap.mapcontext.MapContextManager;

import org.gvsig.fmap.mapcontext.layers.SpatialCache;

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

import org.gvsig.fmap.mapcontrol.MapControlDrawer;

import org.gvsig.fmap.mapcontrol.MapControlLocator;

import org.gvsig.fmap.mapcontrol.MapControlManager;

import org.gvsig.tools.dispose.DisposableIterator;

import org.gvsig.utils.console.JConsole;

/**

 * DOCUMENT ME!

 * 

 * @author Vicente Caballero Navarro

 */

public abstract class DefaultCADTool implements CADTool {

    private static final Logger LOG = LoggerFactory

        .getLogger(DefaultCADTool.class);

    /**

     * Reference to the MapContext library manager, used to create symbols

     * and legends.

     */

    private static MapContextManager mapContextManager = MapContextLocator

        .getMapContextManager();

    /**

     * Reference to the MapControl library manager, used to manage

     * tools.

     */

    protected static MapControlManager mapControlManager = MapControlLocator

        .getMapControlManager();

    private CADToolAdapter cadToolAdapter;

    private String question;

    private String[] currentdescriptions;

    private String tool = "selection";

    private DefaultCADTool previousTool;

    private ArrayList temporalCache = new ArrayList();

    protected GeometryManager geomManager = GeometryLocator

        .getGeometryManager();

    public void addTemporalCache(Geometry geom) {

        temporalCache.add(geom);

        try {

            insertSpatialCache(geom);

        } catch (CreateEnvelopeException e) {

            LOG.error("Error adding the spatial cache", e);

        }

    }

    public void clearTemporalCache() {

        Geometry[] geoms = (Geometry[]) temporalCache.toArray(new Geometry[0]);

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

            try {

                removeSpatialCache(geoms[i]);

            } catch (CreateEnvelopeException e) {

                LOG.error("Error removing the temporal cache", e);

            }

        }

        temporalCache.clear();

    }

    private void insertSpatialCache(Geometry geom)

        throws CreateEnvelopeException {

        VectorialLayerEdited vle = getVLE();

        SpatialCache spatialCache =

            ((FLyrVect) vle.getLayer()).getSpatialCache();

        Envelope r = geom.getEnvelope();

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

            r =

                geomManager.createEnvelope(r.getMinimum(0), r.getMinimum(1),

                    r.getMinimum(0) + 1, r.getMinimum(1) + 1, SUBTYPES.GEOM2D);// Rectangle2D.Double(r.getX(),r.getY(),1,1);

        }

        spatialCache.insert(r, geom);

    }

    private void removeSpatialCache(Geometry geom)

        throws CreateEnvelopeException {

        VectorialLayerEdited vle = getVLE();

        SpatialCache spatialCache =

            ((FLyrVect) vle.getLayer()).getSpatialCache();

        Envelope r = geom.getEnvelope();

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

            r =

                geomManager.createEnvelope(r.getMinimum(0), r.getMinimum(1),

                    r.getMinimum(0) + 1, r.getMinimum(1) + 1, SUBTYPES.GEOM2D);// Rectangle2D.Double(r.getX(),r.getY(),1,1);

        }

        spatialCache.remove(r, geom);

    }

    /**

     * DOCUMENT ME!

     * 

     * @param feature

     */

    public void draw(Geometry geometry, Feature feature) {

        if (geometry != null) {

            getCadToolAdapter().getMapControl().getMapControlDrawer()

                .draw(geometry, mapControlManager.getGeometrySelectionSymbol());

        }

    }

    /**

     * It draw the selected geometries from the initial point until a new

     * point.

     * 

     * @param mapControlDrawer

     *            The drawer.

     * @param firstPoint

     *            The initial point.

     * @param x

     *            The X coordinate of the mouse.

     * @param y

     *            The Y coordinate of the mouse.

     */

    protected void drawSelectedGeometries(MapControlDrawer mapControlDrawer,

        Point2D firstPoint, double x, double y) {

        FeatureStore featureStore = null;

        DisposableIterator iterator = null;

        ICoordTrans ct = getVLE().getLayer().getCoordTrans();

        try {

            featureStore = getVLE().getFeatureStore();

            FeatureSet selection = (FeatureSet) featureStore.getSelection();

            iterator = selection.iterator();

            while (iterator.hasNext()) {

                Feature feature = (Feature) iterator.next();

                Geometry geometry =

                    (feature.getDefaultGeometry()).cloneGeometry();

                if (geometry == null) {

                    continue;

                }

                Point2D currentPoint = new Point2D.Double(x, y);

                if (ct != null) {

                    currentPoint = ct.getInverted().convert(currentPoint, null);

                }

                UtilFunctions.moveGeom(geometry, currentPoint.getX()

                    - firstPoint.getX(),

                    currentPoint.getY() - firstPoint.getY());

                mapControlDrawer.draw(geometry,

                    mapControlManager.getGeometrySelectionSymbol());

            }

        } catch (Exception e) {

            LOG.error("Retrieving the selection", e);

        } finally {

            if (iterator != null) {

                iterator.dispose();

            }

        }

    }

    /**

     * It draw the selected geometries from the initial point until a new

     * point.

     * 

     * @param mapControlDrawer

     *            The drawer.

     * @param firstPoint

     *            The initial point.

     * @param x

     *            The X coordinate of the mouse.

     * @param y

     *            The Y coordinate of the mouse.

     * @param affineTransform

     *            The transformation to apply

     */

    protected void drawAndRotateSelectedGeometries(

        MapControlDrawer mapControlDrawer, Point2D firstPoint, double x,

        double y) {

        FeatureStore featureStore = null;

        DisposableIterator iterator = null;

        ICoordTrans ct = getVLE().getLayer().getCoordTrans();

        try {

            Point2D lastPoint = new Point2D.Double(x, y);

            double w = lastPoint.getX() - firstPoint.getX();

            double h = lastPoint.getY() - firstPoint.getY();

            featureStore = getVLE().getFeatureStore();

            FeatureSet selection = (FeatureSet) featureStore.getSelection();

            iterator = selection.iterator();

            while (iterator.hasNext()) {

                Feature feature = (Feature) iterator.next();

                Geometry geometry =

                    (feature.getDefaultGeometry()).cloneGeometry();

                if (geometry == null) {

                    continue;

                }

                UtilFunctions.rotateGeom(geometry, -Math.atan2(w, h)

                    + (Math.PI / 2), firstPoint.getX(), firstPoint.getY());

                mapControlDrawer.draw(geometry,

                    mapControlManager.getGeometrySelectionSymbol());

            }

        } catch (Exception e) {

            LOG.error("Retrieving the selection", e);

        } finally {

            if (iterator != null) {

                iterator.dispose();

            }

        }

    }

    /**

     * 

     * @param cta

     *            DOCUMENT ME!

     */

    public void setCadToolAdapter(CADToolAdapter cta) {

        cadToolAdapter = cta;

    }

    /**

     * DOCUMENT ME!

     * 

     * @return DOCUMENT ME!

     */

    public CADToolAdapter getCadToolAdapter() {

        return cadToolAdapter;

    }

    public VectorialLayerEdited getVLE() {

        return (VectorialLayerEdited) CADExtension.getEditionManager()

            .getActiveLayerEdited();

    }

    /**

     * DOCUMENT ME!

     * 

     * @param geometry

     *            DOCUMENT ME!

     */

    public Feature insertGeometry(Geometry geometry, Feature feature) {

        VectorialLayerEdited vle = getVLE();

        try {

            FeatureStore featureStore =

                ((FLyrVect) vle.getLayer()).getFeatureStore();

            EditableFeature eFeature =

                featureStore.createNewFeature(

                    featureStore.getDefaultFeatureType(), feature);

            eFeature.setGeometry(featureStore.getDefaultFeatureType()

                .getDefaultGeometryAttributeName(), geometry);

            featureStore.insert(eFeature);

            // drawToImage(featureStore, vle, eFeature);

            insertSpatialCache(geometry);

            getCadToolAdapter().getMapControl().getMapControlDrawer()

                .draw(geometry, mapControlManager.getGeometrySelectionSymbol());

            return eFeature;

        } catch (ReadException e) {

            NotificationManager.addError(e.getMessage(), e);

            return null;

        } catch (DataException e) {

            NotificationManager.addError(e.getMessage(), e);

            return null;

        } catch (CreateEnvelopeException e) {

            NotificationManager.addError(e.getMessage(), e);

            return null;

        }

    }

    public Feature insertAndSelectGeometry(Geometry geometry) {

        Feature feature = null;

        try {

            FeatureStore featureStore = getVLE().getFeatureStore();

            featureStore.beginComplexNotification();

            featureStore.beginEditingGroup(getName());

            FeatureSelection newSelection =

                featureStore.createFeatureSelection();

            feature = insertGeometry(geometry);

            newSelection.select(feature);

            // clearSelection();

            featureStore.setSelection(newSelection);

            featureStore.endEditingGroup();

            featureStore.endComplexNotification();

        } catch (DataException e) {

            NotificationManager.showMessageError("insertAndSelectGeoemtry", e);

        }

        return feature;

    }

    public Feature insertGeometry(Geometry geometry) {

        VectorialLayerEdited vle = getVLE();

        try {

            FeatureStore featureStore =

                ((FLyrVect) vle.getLayer()).getFeatureStore();

            EditableFeature eFeature = featureStore.createNewFeature(true);

            eFeature.setGeometry(featureStore.getDefaultFeatureType()

                .getDefaultGeometryAttributeName(), geometry);

            featureStore.insert(eFeature);

            // drawToImage(featureStore, vle, eFeature);

            insertSpatialCache(geometry);

            getCadToolAdapter().getMapControl().getMapControlDrawer()

                .draw(geometry, mapControlManager.getGeometrySelectionSymbol());

            draw(geometry.cloneGeometry(), eFeature);

            return eFeature;

        } catch (ReadException e) {

            NotificationManager.addError(e.getMessage(), e);

            return null;

        } catch (DataException e) {

            NotificationManager.addError(e.getMessage(), e);

            return null;

        } catch (CreateEnvelopeException e) {

            NotificationManager.addError(e.getMessage(), e);

            return null;

        }

    }

    // private void drawToImage(FeatureStore featureStore,VectorialLayerEdited

    // vle, Feature feature) throws DataException,

    // GeometryOperationNotSupportedException, GeometryOperationException {

    // // clearSelection();

    // // ViewPort vp = vle.getLayer().getMapContext().getViewPort();

    // // BufferedImage selectionImage = new BufferedImage(

    // // vp.getImageWidth(), vp.getImageHeight(),

    // // BufferedImage.TYPE_INT_ARGB);

    // // Graphics2D gs = selectionImage.createGraphics();

    // // BufferedImage handlersImage = new BufferedImage(

    // // vp.getImageWidth(), vp.getImageHeight(),

    // // BufferedImage.TYPE_INT_ARGB);

    // // Graphics2D gh = handlersImage.createGraphics();

    //

    // // int inversedIndex=vea.getInversedIndex(index);

    // // FeatureSelection selection = (FeatureSelection)

    // // featureStore.getSelection();

    // // selection.select(feature);

    // // vle.addSelectionCache(new DefaultRowEdited(df,

    // // IRowEdited.STATUS_ADDED, inversedIndex ));

    // // vea.getSelection().set(inversedIndex);

    // // Geometry geom = (Geometry)feature.getDefaultGeometry();

    // // DrawOperationContext doc = new DrawOperationContext();

    // // doc.setGraphics(gs);

    // // doc.setViewPort(vp);

    // // doc.setSymbol(DefaultCADTool.selectionSymbol);

    // Geometry geometry=feature.getDefaultGeometry();

    // // geometry.cloneGeometry().invokeOperation(Draw.CODE, doc);

    // // // draw(gs, vp, DefaultCADTool.selectionSymbol);

    // // vle.drawHandlers(geometry.cloneGeometry(), gh, vp);

    // // vle.setHandlersImage(handlersImage);

    // // vle.setSelectionImage(selectionImage);

    // try {

    // insertSpatialCache(geometry);

    // } catch (CreateEnvelopeException e) {

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

    // }

    //

    // }

    /**

     * DOCUMENT ME!

     * 

     * @param geometry

     *            DOCUMENT ME!

     */

    // public void modifyFeature(Feature feature, Feature oldFeature) {

    // try {

    // CommandsRecord

    // cr=((FLyrVect)getVLE().getLayer()).getFeatureStore().getCommandsRecord();

    // cr.update(feature, oldFeature);

    // } catch (ReadException e) {

    // NotificationManager.addError(e.getMessage(),e);

    // }

    // draw(((Geometry)feature.getDefaultGeometry()).cloneGeometry());

    // }

    /**

     * DOCUMENT ME!

     * 

     * @param geometry

     *            DOCUMENT ME!

     * @param values

     *            DOCUMENT ME!

     */

    // public Feature addGeometry(Geometry geometry, Object[] values) {

    // // int index = 0;

    // try {

    // FeatureStore featureStore = ((FLyrVect) getVLE().getLayer())

    // .getFeatureStore();

    // EditableFeature eFeature = featureStore.createNewFeature(true);

    // eFeature.setGeometry(featureStore.getDefaultFeatureType()

    // .getDefaultGeometryAttributeName(), geometry);

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

    // eFeature.set(i, values[i]);

    // }

    // featureStore.insert(eFeature);

    // return eFeature;

    // } catch (DataException e) {

    // // TODO Auto-generated catch block

    // e.printStackTrace();

    // }

    // // try {

    // // String newFID = vea.getNewFID();

    // // DefaultFeature df = new DefaultFeature(geometry, values, newFID);

    // // index = vea.addRow(df, getName(), EditionEvent.GRAPHIC);

    // // insertSpatialCache(geometry);

    // // } catch (ValidateRowException e) {

    // // NotificationManager.addError(e);

    // // } catch (ReadException e) {

    // // NotificationManager.addError(e);

    // // }

    // // return vea.getInversedIndex(index);

    // return null;

    // }

    /**

     * Devuelve la cadena que corresponde al estado en el que nos encontramos.

     * 

     * @return Cadena para mostrar por consola.

     */

    public String getQuestion() {

        return question;

    }

    /**

     * Actualiza la cadena que corresponde al estado actual.

     * 

     * @param s

     *            Cadena que aparecer� en consola.

     */

    public void setQuestion(String s) {

        question = s;

        // ConsoleToken.addQuestion(s);

    }

    /**

     * Provoca un repintado "soft" de la capa activa en edici�n. Las capas por

     * debajo de ella no se dibujan de verdad, solo se dibuja la que est� en

     * edici�n y las que est�n por encima de ella en el TOC.

     */

    public void refresh() {

        // getCadToolAdapter().getMapControl().drawMap(false);

        getCadToolAdapter().getMapControl().rePaintDirtyLayers();

    }

    /*

     * public void drawHandlers(Graphics g, FBitSet sel, AffineTransform at)

     * throws DriverIOException { for (int i = sel.nextSetBit(0); i >= 0; i =

     * sel.nextSetBit(i + 1)) { IGeometry ig =

     * getCadToolAdapter().getVectorialAdapter() .getShape(i).cloneGeometry();

     * if (ig == null) continue; Handler[] handlers =

     * ig.getHandlers(IGeometry.SELECTHANDLER);

     * FGraphicUtilities.DrawHandlers((Graphics2D) g, at, handlers); } }

     */

    public void drawHandlers(MapControlDrawer renderer, ArrayList selectedRows,

        AffineTransform at) {

        FeatureSet selection = null;

        DisposableIterator iterator = null;

        try {

            selection =

                (FeatureSet) ((FLyrVect) getVLE().getLayer()).getFeatureStore()

                    .getSelection();

            iterator = selection.iterator();

            while (iterator.hasNext()) {

                Feature feature = (Feature) iterator.next();

                // }

                // for (int i = 0; i < selectedRows.size(); i++) {

                // IRowEdited edRow = (IRowEdited) selectedRows.get(i);

                // IFeature feat = (IFeature) edRow.getLinkedRow();

                // IFeature feat = (IFeature) selectedRows.get(i);

                Geometry ig = (feature.getDefaultGeometry()).cloneGeometry();

                if (ig == null) {

                    continue;

                }

                Handler[] handlers = ig.getHandlers(Geometry.SELECTHANDLER);

                renderer.drawHandlers(handlers, at,

                    mapControlManager.getGeometrySelectionSymbol());

            }

        } catch (ReadException e) {

            // TODO Auto-generated catch block

            e.printStackTrace();

        } catch (DataException e) {

            // TODO Auto-generated catch block

            e.printStackTrace();

        } finally {

            if (iterator != null) {

                iterator.dispose();

            }

        }

    }

    public void setDescription(String[] currentdescriptions) {

        this.currentdescriptions = currentdescriptions;

    }

    public String[] getDescriptions() {

        return currentdescriptions;

    }

    /*

     * (non-Javadoc)

     * 

     * @see com.iver.cit.gvsig.gui.cad.CADTool#end()

     */

    public void end() {

        CADExtension.setCADTool("_selection", true);

        PluginServices.getMainFrame().setSelectedTool("_selection");

        CADTool cadtool = CADExtension.getCADTool();

        cadtool.setPreviosTool(this);

    }

    public void init() {

        // jaume, should not be necessary

        // CADTool.drawingSymbol.setOutlined(true);

        // CADTool.drawingSymbol.setOutlineColor(Color.GREEN);

    }

    // protected ArrayList getSelectedRows() {

    // VectorialLayerEdited vle = getVLE();

    // ArrayList selectedRow = vle.getSelectedRow();

    // return selectedRow;

    // }

    protected ArrayList getSelectedHandlers() {

        VectorialLayerEdited vle = getVLE();

        ArrayList selectedHandlers = vle.getSelectedHandler();

        return selectedHandlers;

    }

    public void clearSelection() throws DataException {

        VectorialLayerEdited vle = getVLE();

        FeatureSelection selection = null;

        selection =

            (FeatureSelection) ((FLyrVect) vle.getLayer()).getFeatureStore()

                .getSelection();

        // ArrayList selectedRow = vle.getSelectedRow();

        ArrayList selectedHandlers = vle.getSelectedHandler();

        selection.deselectAll();

        selectedHandlers.clear();

        // VectorialEditableAdapter vea = vle.getVEA();

        // FBitSet selection = vea.getSelection();

        // selection.clear();

        vle.setSelectionImage(null);

        vle.setHandlersImage(null);

    }

    public String getNextTool() {

        return tool;

    }

    public void setNextTool(String tool) {

        this.tool = tool;

    }

    public boolean changeCommand(String name) throws CommandException {

        CADTool[] cadtools = CADExtension.getCADTools();

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

            CADTool ct = cadtools[i];

            if (name.equalsIgnoreCase(ct.getName())

                || name.equalsIgnoreCase(ct.toString())) {

                int type = Geometry.TYPES.POINT;

                try {

                    type = ((FLyrVect) getVLE().getLayer()).getShapeType();

                } catch (ReadException e) {

                    throw new CommandException(e);

                }

                if (ct.isApplicable(type)) {

                    getCadToolAdapter().setCadTool(ct);

                    ct.init();

                    DefaultViewPanel vista =

                        (DefaultViewPanel) PluginServices.getMDIManager()

                            .getActiveWindow();

                    vista.getConsolePanel().addText("\n" + ct.getName(),

                        JConsole.COMMAND);

                    String question = ct.getQuestion();

                    vista.getConsolePanel().addText(

                        "\n" + "#" + question + " > ", JConsole.MESSAGE);

                    return true;

                }

                throw new CommandException(name);

            }

        }

        return false;

    }

    public boolean isApplicable(int shapeType) {

        return true;

    }

    public abstract String toString();

    public void throwValueException(String s, double d) {

        IWindow window = PluginServices.getMDIManager().getActiveWindow();

        if (window instanceof DefaultViewPanel) {

            ((DefaultViewPanel) window).getConsolePanel().addText(

                s + " : " + d, JConsole.ERROR);

        }

    }

    public void throwOptionException(String s, String o) {

        IWindow window = PluginServices.getMDIManager().getActiveWindow();

        if (window instanceof DefaultViewPanel) {

            ((DefaultViewPanel) window).getConsolePanel().addText(

                s + " : " + o, JConsole.ERROR);

        }

    }

    public void throwPointException(String s, double x, double y) {

        IWindow window = PluginServices.getMDIManager().getActiveWindow();

        if (window instanceof DefaultViewPanel) {

            ((DefaultViewPanel) window).getConsolePanel().addText(

                s + " : " + " X = " + x + ", Y = " + y, JConsole.ERROR);

        }

    }

    public void setPreviosTool(DefaultCADTool tool) {

        previousTool = tool;

    }

    public void restorePreviousTool() {

        CADExtension.setCADTool(previousTool.toString(), true);

        PluginServices.getMainFrame().setSelectedTool(previousTool.toString());

    }

    public void endTransition(double x, double y, MouseEvent e) {

        // TODO Auto-generated method stub

    }

    /**

     * Create a curve. If there is an

     * error return <code>null</code> and add the error

     * to the log

     * 

     * @return

     *         The Curve

     */

    protected Curve createCurve() {

        try {

            return (Curve) geomManager.create(TYPES.CURVE, getSubType());

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

            LOG.error("Error creating curve", new CreateGeometryException(

                TYPES.CURVE, getSubType(), e));

        }

        return null;

    }

    /**

     * Create an {@link OrientablePrimitive}. If there is an

     * error return <code>null</code> and add the error

     * to the log

     * 

     * @param geometryType

     *            a type of a OrientablePrimitive.

     * @return

     *         The {@link OrientablePrimitive}

     */

    protected OrientablePrimitive createOrientablePrimitive(int geometryType) {

        try {

            return (OrientablePrimitive) geomManager.create(geometryType,

                getSubType());

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

            LOG.error("Error creating curve", new CreateGeometryException(

                TYPES.CURVE, getSubType(), e));

        }

        return null;

    }

    /**

     * Create an envelope like a curve from two points.

     * If there is an error return <code>null</code> and add the error to the

     * log.

     * 

     * @param firstPoint

     *            first point

     * @param secondPoint

     *            second point

     * @return

     *         the curve

     */

    protected Curve createEnvelopeLikeCurve(Point2D firstPoint,

        Point2D secondPoint) {

        try {

            Curve curve = (Curve) geomManager.create(TYPES.CURVE, getSubType());

            curve.addMoveToVertex(createPoint(firstPoint.getX(),

                firstPoint.getY()));

            curve.addVertex(createPoint(secondPoint.getX(), firstPoint.getY()));

            curve

                .addVertex(createPoint(secondPoint.getX(), secondPoint.getY()));

            curve.addVertex(createPoint(firstPoint.getX(), secondPoint.getY()));

            curve.addVertex(createPoint(firstPoint.getX(), firstPoint.getY()));

            return curve;

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

            LOG.error("Error creating curve", new CreateGeometryException(

                TYPES.CURVE, getSubType(), e));

        }

        return null;

    }

    /**

     * Create a curve from a GeneralPath. If there is an

     * error return <code>null</code> and add the error

     * to the log

     * 

     * @param gpx

     *            The GeneralPath

     * @return

     *         The Curve

     */

    protected Curve createCurve(GeneralPathX gpx) {

        Curve curve = null;

        try {

            curve = (Curve) geomManager.create(TYPES.CURVE, getSubType());

            curve.setGeneralPath(gpx);

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

            LOG.error("Error creating curve", new CreateGeometryException(

                TYPES.CURVE, getSubType(), e));

        }

        return curve;

    }

    /**

     * Create a surface. If there is an

     * error return <code>null</code> and add the error

     * to the log

     * 

     * @return

     *         The Surface

     */

    protected Surface createSurface() {

        try {

            return (Surface) geomManager.create(TYPES.SURFACE, getSubType());

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

            LOG.error("Error creating surface", new CreateGeometryException(

                TYPES.SURFACE, getSubType(), e));

        }

        return null;

    }

    /**

     * Create a surface from a GeneralPath. If there is an

     * error return <code>null</code> and add the error

     * to the log

     * 

     * @param gpx

     *            The general path

     * @return

     *         The Surface

     */

    protected Surface createSurface(GeneralPathX gpx) {

        Surface surface = null;

        try {

            surface = (Surface) geomManager.create(TYPES.SURFACE, getSubType());

            surface.setGeneralPath(gpx);

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

            LOG.error("Error creating surface", new CreateGeometryException(

                TYPES.SURFACE, getSubType(), e));

        }

        return surface;

    }

    /**

     * Create a curve point. If there is an

     * error return <code>null</code> and add the error

     * to the log

     * 

     * @param p1

     *            The AWT point

     * @return

     *         The gvSIG point

     */

    protected Point createPoint(Point2D p1) {

        return createPoint(p1.getX(), p1.getY());

    }

    /**

     * Create point. If there is an

     * error return <code>null</code> and add the error

     * to the log

     * 

     * @param x

     *            The X coordinate

     * @param y

     *            The y coordinate

     * @return

     *         The Point

     */

    protected Point createPoint(double x, double y) {

        Point point = null;

        try {

            point = (Point) geomManager.create(TYPES.POINT, getSubType());

            point.setX(x);

            point.setY(y);

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

            LOG.error("Error creating point with x=" + x + ", y=" + y,

                new CreateGeometryException(TYPES.POINT, getSubType(), e));

        }

        return point;

    }

    /**

     * Create an Arc. If there is an

     * error return <code>null</code> and add the error

     * to the log

     * 

     * @param p1

     * @param p2

     * @param p3

     * @return

     *         The arc

     */

    protected Arc createArc(Point2D p1, Point2D p2, Point2D p3) {

        return createArc(createPoint(p1), createPoint(p2), createPoint(p3));

    }

    /**

     * Create an arc. If there is an

     * error return <code>null</code> and add the error

     * to the log

     * 

     * @param p1

     * @param p2

     * @param p3

     * @return

     *         The arc

     */

    protected Arc createArc(Point p1, Point p2, Point p3) {

        Arc arc = null;

        if (p1.equals(p2) || p2.equals(p3) || p1.equals(p3)) {

            return null;

        }

        try {

            arc = (Arc) geomManager.create(TYPES.ARC, getSubType());

            arc.setPoints(p1, p2, p3);

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

            LOG.error("Error creating arc with p1=" + p1, ", p2=" + p2

                + ", p3=" + p3, new CreateGeometryException(TYPES.ARC,

                getSubType(), e));

        }

        return arc;

    }

    /**

     * Create a circle. If there is an

     * error return <code>null</code> and add the error

     * to the log

     * 

     * @param p1

     * @param p2

     * @param p3

     * @return

     *         The Circle

     */

    protected Circle createCircle(Point p1, Point p2, Point p3) {

        Circle circle = null;

        try {

            circle = (Circle) geomManager.create(TYPES.CIRCLE, getSubType());

            circle.setPoints(p1, p2, p3);

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

            LOG.error("Error creating circle with p1=" + p1 + " p2=" + p2

                + ", p3=" + p3, new CreateGeometryException(TYPES.CIRCLE,

                getSubType(), e));

        }

        return circle;

    }

    /**

     * Create a circle from a GeneralPath. If there is an

     * error return <code>null</code> and add the error

     * to the log

     * 

     * @param p1

     * @param p2

     * @return

     *         The circle

     */

    protected Circle createCircle(Point2D p1, Point2D p2) {

        return createCircle(createPoint(p1), createPoint(p2));

    }

    /**

     * Create a circle. If there is an

     * error return <code>null</code> and add the error

     * to the log

     * 

     * @param p1

     * @param p2

     * @return

     *         The circle

     */

    protected Circle createCircle(Point p1, Point p2) {

        Circle circle = null;

        try {

            circle = (Circle) geomManager.create(TYPES.CIRCLE, getSubType());

            circle.setPoints(p1, p2);

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

            LOG.error("Error creating circle with p1=" + p1 + " p2=" + p2,

                new CreateGeometryException(TYPES.CIRCLE, getSubType(), e));

        }

        return circle;

    }

    /**

     * Create a circle. If there is an

     * error return <code>null</code> and add the error

     * to the log

     * 

     * @param p1

     * @param radious

     * @return

     *         The Circle

     */

    protected Circle createCircle(Point2D p1, double radious) {

        return createCircle(createPoint(p1), radious);

    }

    /**

     * Create a circle. If there is an

     * error return <code>null</code> and add the error

     * to the log

     * 

     * @param p1

     * @param radious

     * @return

     *         The Circle

     */

    protected Circle createCircle(Point p1, double radious) {

        Circle circle = null;

        try {

            circle = (Circle) geomManager.create(TYPES.CIRCLE, getSubType());

            circle.setPoints(p1, radious);

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

            LOG.error("Error creating circle with p1=" + p1 + " radious="

                + radious, new CreateGeometryException(TYPES.CIRCLE,

                getSubType(), e));

        }

        return circle;

    }

    /**

     * Create an Ellipse. If there is an

     * error return <code>null</code> and add the error

     * to the log

     * 

     * @param p1

     * @param p2

     * @param d

     * @return

     *         The Ellipse

     */

    protected Ellipse createEllipse(Point2D p1, Point2D p2, double d) {

        return createEllipse(createPoint(p1), createPoint(p2), d);

    }

    /**

     * Create an Ellipse. If there is an

     * error return <code>null</code> and add the error

     * to the log

     * 

     * @param p1

     * @param p2

     * @param d

     * @return

     *         The Ellipse

     */

    protected Ellipse createEllipse(Point p1, Point p2, double d) {

        Ellipse ellipse = null;

        try {

            ellipse = (Ellipse) geomManager.create(TYPES.ELLIPSE, getSubType());

            ellipse.setPoints(p1, p2, d);

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

            LOG.error("Error creating ellipse with p1=" + p1 + " p2=" + p2

                + ", d=" + d, new CreateGeometryException(TYPES.ELLIPSE,

                getSubType(), e));

        }

        return ellipse;

    }

    /**

     * Create a Spline from a GeneralPath. If there is an

     * error return <code>null</code> and add the error

     * to the log

     * 

     * @param points

     * @return

     *         The Spline

     */

    protected Spline createSpline(Point2D[] points) {

        Spline spline = null;

        try {

            spline = (Spline) geomManager.create(TYPES.SPLINE, getSubType());

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

                spline.addVertex(createPoint(points[i]));

            }

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

            LOG.error("Error creating spline", new CreateGeometryException(

                TYPES.SPLINE, getSubType(), e));

        }

        return spline;

    }

    /**

     * Create a MultiPrimitive. If there is an

     * error return <code>null</code> and add the error

     * to the log

     * 

     * @return

     */

    protected MultiPrimitive createMultiPrimitive() {

        try {

            return (MultiPrimitive) geomManager.create(TYPES.AGGREGATE,

                getSubType());

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

            LOG.error("Error creating MultiPrimitive",

                new CreateGeometryException(TYPES.SPLINE, getSubType(), e));

        }

        return null;

    }

    /**

     * Create a MultiPrimitive. If there is an

     * error return <code>null</code> and add the error

     * to the log

     * 

     * @param geometries

     * @return

     */

    protected MultiPrimitive createMultiPrimitive(Geometry[] geometries) {

        MultiPrimitive multiPrimitive = null;

        try {

            multiPrimitive =

                (MultiPrimitive) geomManager.create(TYPES.AGGREGATE,

                    getSubType());

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

                multiPrimitive.addPrimitive((Primitive) geometries[i]);

            }

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

            LOG.error("Error creating MultiPrimitive",

                new CreateGeometryException(TYPES.SPLINE, getSubType(), e));

        }

        return multiPrimitive;

    }

    /**

     * @return the subtype of the default geometry.

     */

    protected int getSubType() {

        FeatureStore featureStore =

            ((FLyrVect) getVLE().getLayer()).getFeatureStore();

        try {

            return featureStore.getDefaultFeatureType()

                .getDefaultGeometryAttribute().getGeometrySubType();

        } catch (DataException e) {

            LOG.error(

                "Error getting subtype of the default feature type of the store: "

                    + featureStore, e);

            return SUBTYPES.GEOM3D;

        }

    }

}