Application: gvSIG desktop » gvSIG tools: Vector editing

continue= Continue

do_not_save_yet_stay_in_editing_mode= Don't save changes and continue editing 

indicate_new_point= Indicate new point

arc_mode = Arc mode

line_mode = Line mode

select_new_tool= Select a new tool

inscribed = Inscribed

circumscribed = Circumscribed

sides_of_regular_polygon = Indicate sides of regular polygon

center_of_regular_polygon = Center of regular polygon

point_of_circle = Point of circle of  polygon

sides = Sides

key_arc_mode = A

key_line_mode = L

key_close = C

key_finish = F

close_polyline = Close polyline

close_spline = Close spline curve

new_point = New point

new_value = New value

inscribed = Inscrito

circumscribed = Circunscrito

sides_of_regular_polygon = Indique los lados del poligono regular

center_of_regular_polygon = Centro del pol\u00edguno regular 

point_of_circle = Punto del c\u00edrculo del pol\u00edgono

sides = Lados

key_arc_mode = A

key_line_mode = L

key_close = C

key_finish = T

close_polyline = Cerrar polil\u00ednea

close_spline = Cerrar curva spline

new_point = Nuevo punto

new_value = Nuevo valor

package org.gvsig.vectorediting.lib.spi;

import java.util.List;

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

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

public interface EditingProviderServices extends ProviderServices {

    /**

     * Inserts the feature into feature store.

     *

     * @param feature

     */

    public Ellipse createFilledEllipse(Point firstPointAxisA,

        Point secondPointAxisA, double halfLengthAxisB, int subtype)

    /**

     * Create point with x and y values.

import java.util.Iterator;

import java.util.List;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.gvsig.fmap.geom.type.GeometryType;

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

import org.gvsig.fmap.mapcontrol.MapControlLocator;

import org.gvsig.tools.exception.BaseException;

import org.gvsig.tools.service.spi.AbstractProviderServices;

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

public class DefaultEditingProviderServices extends AbstractProviderServices

    private static final Logger logger = LoggerFactory

        .getLogger(DefaultEditingProviderServices.class);

            if (notification.isCanceled()) {

                String msg =

                    String

                throw new CancelationException(msg, null);

            }

            if (notification.isCanceled()) {

                String msg =

                    String

                throw new CancelationException(msg, null);

            }

            if (notification.isCanceled()) {

                String msg =

                    String

                throw new CancelationException(msg, null);

            }

    public Ellipse createFilledEllipse(Point firstPointAxisA,

        Point secondPointAxisA, double halfLengthAxisB, int subtype)

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

        ellipse.setPoints(firstPointAxisA, secondPointAxisA, halfLengthAxisB);

        return ellipse;

        }

    }

    public Curve createLine(Point p1, Point p2, int subtype)

        throws CreateGeometryException, DataException {

        return this.createLine(p1.getX(), p1.getY(), p2.getX(), p2.getY(),

            subtype);

    }

    public Spline createSpline(List<Point> points, int subtype)

        throws CreateGeometryException {

        Spline spline = null;

        return spline;

    }

}

    private final static String PROVIDER_DESCRIPTION =

        "Creates arcs with three points";

    public void initialize() {

    }

    public EditingServiceInfo getServiceInfo() {

        EditingServiceInfo serviceInfo =

            new DefaultEditingServiceinfo(PROVIDER_NAME, "", true, null,

        return serviceInfo;

    }

    @Override

    protected Provider doCreate(DynObject parameters, ProviderServices services) {

        return new ArcEditingProvider(services, parameters);

    }

    @Override

    public DynObject createParameters() {

        DynObject parameters = super.createParameters();

        return parameters;

    }

    @Override

    protected DynClass createParametersDynClass() {

        DynClass dynclass =

 *

 */

public class RegularPolygonEditingProvider extends AbstractEditingProvider

    protected EditingServiceParameter polygonSides;

        super(providerServices);

        this.featureStore =

            (FeatureStore) parameters

        polygonSides =

            new DefaultEditingServiceParameter("sides",

        options.put(i18nManager.getTranslation("key_circumscribed"),

            "circumscribed");

        mode =

                EditingServiceParameter.TYPE.OPTION);

        center =

     */

    protected Curve calculateRegularPolygon(String modeValue,

        Point centerValue, Point pointOfCircle, int sidesValue)

        GeometryManager geometryManager = GeometryLocator.getGeometryManager();

    public FilledSplineEditingProvider(ProviderServices services,

        DynObject parameters) {

        super(services, parameters);

        I18nManager i18nManager = ToolsLocator.getI18nManager();

        options = new LinkedHashMap<String, String>();

        options.put(i18nManager.getTranslation("key_finish"), "finish");

        this.points =

                EditingServiceParameter.TYPE.OPTION);

    }

    public DrawingStatus getDrawingStatus(Point mousePosition)

        throws DrawServiceException {

                        editingProviderServices.createSpline(values, subtype);

                    spline.addVertex(mousePosition);

                    spline.addVertex(values.get(0));

                    drawingStatus.addGeometry(spline);

                GeometryLocator.getGeometryManager();

            try {

                int subtype = editingProviderServices.getSubType(featureStore);

                Spline spline =

                    editingProviderServices.createSpline(values, subtype);

                spline.addVertex(values.get(0));

                Surface surface = geometryManager.createPolygon(subtype);

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

                    surface.addVertex(spline.getVertex(i));

        options.put(i18nManager.getTranslation("key_close"), "close_spline");

        options.put(i18nManager.getTranslation("key_finish"), "finish");

        this.points =

                EditingServiceParameter.TYPE.OPTION);

        this.closeSpline = false;

            EditingProviderServices editingProviderServices =

                (EditingProviderServices) getProviderServices();

            try {

                if (closeSpline) {

                    values.add(values.get(0));

                }

                int subtype = editingProviderServices.getSubType(featureStore);

                Spline spline =

                    editingProviderServices.createSpline(values, subtype);

                GeometryType geomType =

                    editingProviderServices.getGeomType(featureStore);

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

public class PolygonEditingProvider extends PolylineEditingProvider implements

    public PolygonEditingProvider(ProviderServices providerServices,

        DynObject parameters) {

        super(providerServices, parameters);

        I18nManager i18nManager = ToolsLocator.getI18nManager();

        this.options = new LinkedHashMap<String, String>();

        options.put(i18nManager.getTranslation("key_arc_mode"), "arc_mode");

        options.put(i18nManager.getTranslation("key_line_mode"), "line_mode");

        options.put(i18nManager.getTranslation("key_finish"), "finish");

        this.points =

    }

    @Override

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

public class PolylineEditingProvider extends AbstractEditingProvider implements

    protected EditingProviderServices editingProviderServices =

        (EditingProviderServices) getProviderServices();

        // Initialize all provider variables.

        this.featureStore =

            (FeatureStore) parameters

        I18nManager i18nManager = ToolsLocator.getI18nManager();

        options.put(i18nManager.getTranslation("key_close"), "close_polyline");

        options.put(i18nManager.getTranslation("key_finish"), "finish");

        points =

        arcMode = false;

        finishPolyline = false;

                                        + " [(%1$s,%2$s),(%3$s,%4$s)]"

                                        + " and perperdicular"

                                        + " [(%5$s,%6$s),(%7$s,%8$s)]",

                            throw new DrawServiceException(msg, null);

                        }

                                startAngle, angleExt, subtype);

                        Curve inverseArc =

                            (Curve) GeometryLocator.getGeometryManager()

                        if (!point.equals(arco.getVertex(0))) {

                            for (int j = arco.getNumVertices() - 1; j >= 0; j--) {

                                inverseArc.addVertex(arco.getVertex(j));

                    antm =

                        -(nextPoint.getX() - center.getX())

                    if (antm == Double.POSITIVE_INFINITY) {

                        antb = Double.NEGATIVE_INFINITY;

                        if (nextPoint.getX() == 0) {

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

public class SymmetryEditingProvider extends AbstractEditingProvider implements

    private I18nManager i18nManager = ToolsLocator.getI18nManager();

        super(providerServices);

        this.featureStore =

            (FeatureStore) parameters

        this.selectionParameter =

                i18nManager.getTranslation("selection"), TYPE.SELECTION);

        this.firstPointParameter =

        options.put(i18nManager.getTranslation("short_no"),

            "keep_original_geometries");

        this.deleteOriginalGeometriesParameter =

            new DefaultEditingServiceParameter("Delete original geometries",

    }

    public DrawingStatus getDrawingStatus(Point mousePosition)

                    line =

                        GeometryLocator.getGeometryManager().createLine(

                            featureStore.getDefaultFeatureType()

                    line.addVertex(p1);

                    line.addVertex(p2);

        AffineTransform translate =

            AffineTransform

        EditingProviderServices editingProviderServices =

            (EditingProviderServices) getProviderServices();

                                feature.getEditable();

                            editableFeature.setDefaultGeometry(geom);

                            ((EditingProviderServices) getProviderServices())

                        } else {

                            // Se crea una feature nueva copiando los valores de

                            // la feature original excepto aquellos que sean PK

                                (EditingProviderServices) getProviderServices();

                            EditableFeature editableFeature =

                                editingProviderServices

                            editableFeature.setDefaultGeometry(geom);

                            ((EditingProviderServices) getProviderServices())

                        }

                    }

                    it.dispose();

            try {

                selected =

                    (FeatureSelection) featureStore.getFeatureSelection()

            } catch (DataException e) {

                throw new StartServiceException(e);

            } catch (CloneNotSupportedException e) {