Application: gvSIG desktop » gvSIG tools: Vector editing

package org.gvsig.vectorediting.lib.prov.editvertex.operation;

import java.util.ArrayList;

import java.util.List;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryManager;

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

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

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

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

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

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

import org.gvsig.vectorediting.lib.spi.DefaultDrawingStatus;

import org.gvsig.vectorediting.lib.spi.EditingProviderLocator;

import org.gvsig.vectorediting.lib.spi.EditingProviderManager;

public class PolygonEditVertexOperation implements EditVertexOperation {

    public PolygonEditVertexOperation() {

        // TODO Auto-generated constructor stub

    }

    public Geometry insertVertex(Primitive geom, int index)

        throws CreateGeometryException {

        GeometryManager geometryManager = GeometryLocator.getGeometryManager();

        Polygon result =

            geometryManager.createPolygon(geom.getGeometryType().getSubType());

        Polygon polygon = (Polygon) geom;

        int numVertices = polygon.getNumVertices();

        boolean added = false;

        Point lastVertex = polygon.getVertex(numVertices - 1);

        if (index < 0 || index >= numVertices) {

            return geom;

        }

        int indexToInsert = index;

        if (index == 0 && polygon.getVertex(0).equals(lastVertex)) {

            indexToInsert = numVertices - 1;

        }

        if (indexToInsert == 0) {

            Point point = polygon.getVertex(0);

            if (!point.equals(lastVertex)) {

                result.addVertex(geometryManager.createPoint(

                    (point.getX() + lastVertex.getX()) / 2,

                    (point.getY() + lastVertex.getY()) / 2, geom

                        .getGeometryType().getSubType()));

                added = true;

            }

        }

        Point antPoint = null;

        for (int i = 0; i < numVertices; i++) {

            Point point = polygon.getVertex(i);

            if (i == indexToInsert && !added) {

                result.addVertex(geometryManager.createPoint(

                    (point.getX() + antPoint.getX()) / 2,

                    (point.getY() + antPoint.getY()) / 2, geom

                        .getGeometryType().getSubType()));

            }

            result.addVertex(point);

            antPoint = point;

        }

        return result;

    }

    public Geometry removeVertex(Primitive geom, int index)

        throws CreateGeometryException {

        Polygon polygon = (Polygon) geom;

        int numVertices = polygon.getNumVertices();

        if (index < 0 || index >= numVertices) {

            return geom;

        }

        GeometryManager geometryManager = GeometryLocator.getGeometryManager();

        Polygon result =

            geometryManager.createPolygon(geom.getGeometryType().getSubType());

        if (polygon.getVertex(0).equals(polygon.getVertex(numVertices - 1))) {

            if (numVertices <= 4) {

                return geom;

            }

            numVertices--;

        } else {

            if (numVertices <= 3) {

                return geom;

            }

        }

        int j = 0;

        for (int i = 0; i < numVertices; i++) {

            Point point = polygon.getVertex(i);

            if (i == index) {

                continue;

            }

            result.addVertex(point);

            j++;

        }

        if (!result.getVertex(0).equals(result.getVertex(j - 1))) {

            result.addVertex(result.getVertex(0));

        }

        return result;

    }

    public Geometry moveVertex(Primitive geom, int index, Point point) {

        Polygon result = (Polygon) geom.cloneGeometry();

        int numVertices = result.getNumVertices();

        if (result.getVertex(0).equals(result.getVertex(numVertices - 1))) {

            if (index == 0 || index == (result.getNumVertices() - 1)) {

                EditVertexOperationUtils.setVertex(result, 0, point);

                EditVertexOperationUtils.setVertex(result,

                    result.getNumVertices() - 1, (Point)point.cloneGeometry());

                return result;

            }

        }

        EditVertexOperationUtils.setVertex(result, index, point);

        return result;

    }

    public List<Point> getVertexesList(Primitive geom) {

        ArrayList<Point> vertexList = new ArrayList<Point>();

        if (geom instanceof OrientablePrimitive) {

            OrientablePrimitive orientable = (OrientablePrimitive) geom;

            orientable.getNumVertices();

            for (int i = 0; i < orientable.getNumVertices(); i++) {

                vertexList.add(orientable.getVertex(i));

            }

        }

        return vertexList;

    }

    public int getNumVertex(Primitive geom) {

        if (geom instanceof OrientablePrimitive) {

            OrientablePrimitive orientable = (OrientablePrimitive) geom;

            return orientable.getNumVertices();

        }

        return 0;

    }

    public boolean canInsertVertex(Primitive geom, int index) {

        return true;

    }

    public boolean canRemoveVertex(Primitive geom, int index) {

        Polygon polygon = (Polygon) geom;

        int numVertices = polygon.getNumVertices();

        if (index < 0) {

            return false;

        } else if (index >= numVertices) {

            return false;

        }

        if (polygon.getVertex(0).equals(polygon.getVertex(numVertices - 1))) {

            if (numVertices <= 4) {

                return false;

            }

        } else {

            if (numVertices <= 3) {

                return false;

            }

        }

        return true;

    }

    public boolean canMoveVertex(int index, Point point) {

        return true;

    }

    public void addToDrawingStatus(DefaultDrawingStatus drawingStatus,

        Primitive primitive) {

        EditingProviderManager editingProviderManager =

            EditingProviderLocator.getProviderManager();

        ISymbol polygonSymbolEditing =

            editingProviderManager.getSymbol("polygon-symbol-editing");

        drawingStatus.addStatus(primitive, polygonSymbolEditing, "");

    }

}