Application: gvSIG desktop » gvSIG tools: Vector editing

import org.gvsig.vectorediting.lib.prov.internalpolygon.InternalPolygonEditingProviderFactory;

    manager.addProviderFactory(new InternalPolygonEditingProviderFactory());

import org.gvsig.fmap.geom.Geometry;

  public void finishAndStore() throws FinishServiceException {

    provider.finishAndStore();

  public Geometry finish() throws FinishServiceException{

    return provider.finish();

  }

		<dependency>

			<groupId>org.gvsig</groupId>

			<artifactId>

				org.gvsig.vectorediting.lib.prov.internalpolygon

			</artifactId>

		</dependency>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">

  <modelVersion>4.0.0</modelVersion>

  <parent>

    <groupId>org.gvsig</groupId>

    <artifactId>org.gvsig.vectorediting.lib.prov</artifactId>

    <version>1.0.0-SNAPSHOT</version>

  </parent>

  <artifactId>org.gvsig.vectorediting.lib.prov.internalpolygon</artifactId>

  <name>org.gvsig.vectorediting.lib.prov.internalpolygon</name>

</project>

/*

 * Copyright 2014 DiSiD Technologies S.L.L. All rights reserved.

 * 

 * Project  : DiSiD org.gvsig.vectorediting.lib.prov.internalpolygon 

 * SVN Id   : $Id$

 */

package org.gvsig.vectorediting.lib.prov.internalpolygon;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

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

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

import org.gvsig.fmap.geom.Geometry;

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

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dispose.DisposableIterator;

import org.gvsig.tools.dynobject.DynObject;

import org.gvsig.tools.i18n.I18nManager;

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

import org.gvsig.vectorediting.lib.api.DrawingStatus;

import org.gvsig.vectorediting.lib.api.EditingServiceParameter;

import org.gvsig.vectorediting.lib.api.EditingServiceParameter.TYPE;

import org.gvsig.vectorediting.lib.api.exceptions.DrawServiceException;

import org.gvsig.vectorediting.lib.api.exceptions.FinishServiceException;

import org.gvsig.vectorediting.lib.api.exceptions.InvalidEntryException;

import org.gvsig.vectorediting.lib.api.exceptions.StartServiceException;

import org.gvsig.vectorediting.lib.api.exceptions.StopServiceException;

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

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

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

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

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

public class InternalPolygonEditingProvider extends AbstractEditingProvider

    implements EditingProvider {

  private I18nManager i18nManager = ToolsLocator.getI18nManager();

  private EditingProviderServices editingProviderServices = (EditingProviderServices) getProviderServices();

  private EditingServiceParameter selectionParameter = new DefaultEditingServiceParameter(

      "Select geometry", i18nManager.getTranslation("selection"),

      TYPE.SELECTION);

  private EditingServiceParameter geometryParameter = new DefaultEditingServiceParameter(

      "Draw geometry", i18nManager.getTranslation("draw_geometry"),

      TYPE.GEOMETRY);

  private FeatureStore featureStore;

  private Map<EditingServiceParameter, Object> values;

  public InternalPolygonEditingProvider(ProviderServices services,

      DynObject parameters) {

    super(services);

    this.featureStore = (FeatureStore) parameters

        .getDynValue(EditingProviderFactory.FEATURE_STORE_FIELD);

  }

  public EditingServiceParameter next() {

    if (values.get(selectionParameter) == null) {

      return selectionParameter;

    }

    else if (values.get(geometryParameter) == null) {

      return geometryParameter;

    }

    return null;

  }

  public DrawingStatus draw(Point mousePosition) throws DrawServiceException {

    return null;

  }

  public void stop() throws StopServiceException {}

  public List<EditingServiceParameter> getParameters() {

    List<EditingServiceParameter> list = new ArrayList<EditingServiceParameter>();

    list.add(selectionParameter);

    list.add(geometryParameter);

    return list;

  }

  public void value(Object value) throws InvalidEntryException {

    EditingServiceParameter param = next();

    validateAndInsertValue(param, value);

  }

  private void validateAndInsertValue(EditingServiceParameter param,

                                      Object value) {

    if (param == selectionParameter) {

      if (value instanceof FeatureSelection) {

        values.put(param, value);

        return;

      }

    }

    else if (param == geometryParameter) {

      if (value instanceof Geometry) {

        values.put(param, value);

        return;

      }

    }

  }

  public void finishAndStore() throws FinishServiceException {

    FeatureSelection selected = (FeatureSelection) values

        .get(selectionParameter);

    Geometry geometry = (Geometry) values.get(geometryParameter);

    try {

      if (!selected.isEmpty()) {

        DisposableIterator it;

        it = selected.fastIterator();

        while (it.hasNext()) {

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

          Geometry geom = (Geometry) feature.getDefaultGeometry()

              .cloneGeometry();

          Geometry newGeom = geom.difference(geometry);

          EditableFeature editableFeature = feature.getEditable();

          editableFeature.setDefaultGeometry(newGeom);

          editingProviderServices.updateFeatureInFeatureStore(editableFeature,

              featureStore);

        }

      }

    }

    catch (Exception e) {

      throw new FinishServiceException("Can't finalize " + this.getName(), e);

    }

  }

  public Geometry finish() throws FinishServiceException {

    return null;

  }

  public void start() throws StartServiceException {

    this.values = new HashMap<EditingServiceParameter, Object>();

    FeatureSelection selected = null;

    if (featureStore != null) {

      try {

        selected = featureStore.getFeatureSelection();

      }

      catch (DataException e) {

        throw new StartServiceException(e);

      }

      if (selected != null && selected.getSelectedCount() > 0) {

        values.put(selectionParameter, selected);

      }

    }

  }

  public String getName() {

    return InternalPolygonEditingProviderFactory.PROVIDER_NAME;

  }

}

/*

 * Copyright 2014 DiSiD Technologies S.L.L. All rights reserved.

 * 

 * Project  : DiSiD org.gvsig.vectorediting.lib.prov.internalpolygon 

 * SVN Id   : $Id$

 */

package org.gvsig.vectorediting.lib.prov.internalpolygon;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DynClass;

import org.gvsig.tools.dynobject.DynObject;

import org.gvsig.tools.dynobject.DynObjectManager;

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

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

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

import org.gvsig.vectorediting.lib.api.EditingServiceInfo;

import org.gvsig.vectorediting.lib.api.EditingServiceParameter;

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

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

public class InternalPolygonEditingProviderFactory extends AbstractProviderFactory

    implements EditingProviderFactory {

  public final static String PROVIDER_NAME = "internal-polygon";

  public final static String PROVIDER_DESCRIPTION = "";

  public void initialize() {}

  public EditingServiceInfo getServiceInfo() {

    EditingServiceInfo serviceInfo = new DefaultEditingServiceinfo(

        PROVIDER_NAME, "", true, null, null, new int[] {

            Geometry.TYPES.SURFACE, Geometry.TYPES.MULTISURFACE });

    return serviceInfo;

  }

  public EditingServiceParameter getServiceParameterInfo() {

    // TODO Auto-generated method stub

    return null;

  }

  @Override

  protected Provider doCreate(DynObject parameters, ProviderServices services) {

    return new InternalPolygonEditingProvider(services, parameters);

  }

  @Override

  protected DynClass createParametersDynClass() {

    DynObjectManager dynObjectManager = ToolsLocator.getDynObjectManager();

    DynClass dynclass = dynObjectManager.createDynClass(

        PROVIDER_NAME, PROVIDER_DESCRIPTION);

    dynclass.addDynFieldString(PROVIDER_NAME_FIELD);

    dynclass.addDynFieldObject(FEATURE_STORE_FIELD);

    return dynclass;

  }

  public DynObject createParameters() {

    DynObject parameters = super.createParameters();

    parameters.setDynValue(PROVIDER_NAME_FIELD, PROVIDER_NAME);

    return parameters;

  }

}

        Curve line = ((EditingProviderServices) getProviderServices())

            .createLine(centerPoint.getX(), centerPoint.getY(),

                mousePosition.getX(), mousePosition.getY(), featureStore);

        geometries.addGeometry(circle);

        geometries.addGeometry(centerPoint);

        geometries.addGeometry(line);

        throw new DrawServiceException(e);

                                      Object value)

      throws InvalidEntryException {

  public void value(Object value) throws InvalidEntryException {

  public void finishAndStore() throws FinishServiceException {

    EditingProviderServices editingProviderServices = (EditingProviderServices) getProviderServices();

    Geometry geometry = finish();

    editingProviderServices.insertGeometryIntoFeatureStore(geometry, featureStore);

  }

  public Geometry finish() throws FinishServiceException {

      GeometryType storeGeomType = editingProviderServices

          .getGeomType(featureStore);

      Geometry geometry = null;

      if (storeGeomType.isTypeOf(SURFACE)) {

      }

      else if (storeGeomType.isTypeOf(CURVE)) {

      }

      else if (storeGeomType.isTypeOf(MULTISURFACE)) {

        MultiSurface multisurface;

        multisurface.addSurface((Circle) geometry);

      }

      else if (storeGeomType.isTypeOf(MULTICURVE)) {

        MultiCurve multicurve;

        multicurve = geomManager.createMultiCurve(storeGeomType.getSubType());

        multicurve.addCurve((Arc) geometry);

      }

      return geometry;

		<module>

			org.gvsig.vectorediting.lib.prov.internalpolygon

		</module>

	public void finishAndStore() throws FinishServiceException {

	public Geometry finish() throws FinishServiceException{

	  return null;

	}

  public void finishAndStore() throws FinishServiceException {

      Geometry geometry = finish();

      if (geometry == null) {

        if (storeGeomType.isTypeOf(CURVE)) {

          DrawingStatus finalGeometries = calculatePolyline(null);

          for (Geometry geom : finalGeometries.getGeometries()) {

            editingProviderServices.insertGeometryIntoFeatureStore(geom,

                featureStore);

          }

        }

        else if (storeGeomType.isTypeOf(MULTICURVE)) {

          DrawingStatus finalGeometries = calculatePolyline(null);

          MultiCurve multiCurve;

          multiCurve = geomManager.createMultiCurve(storeGeomType.getSubType());

          for (Geometry geom : finalGeometries.getGeometries()) {

            multiCurve.addCurve((Curve) geom);

          }

          editingProviderServices.insertGeometryIntoFeatureStore(multiCurve,

              featureStore);

        }

      }

      else {

        editingProviderServices.insertGeometryIntoFeatureStore(geometry,

            featureStore);

      }

    }

    catch (Exception e) {

      throw new FinishServiceException(e);

    }

  }

  public Geometry finish() throws FinishServiceException {

    try {

      GeometryType storeGeomType = editingProviderServices

          .getGeomType(featureStore);

        DrawingStatus finalGeometries = calculatePolyline(null);

        return (Geometry) surface;

        DrawingStatus finalGeometries = calculatePolyline(null);

        return (Geometry) multiSurface;

      return null;

    if (values != null) {

import org.apache.log4j.Logger;

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

import org.gvsig.fmap.geom.Geometry;

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

      "Insert point", i18nManager.getTranslation("indicate_new_point"),

      TYPE.POSITION);

  public void stop() {

    else {

  public void finishAndStore() throws FinishServiceException {

    Geometry geometry = null;

    try {

      geometry = finish();

    catch (Exception e) {

      throw new FinishServiceException("Can't finalize " + this.getName()

          + "with X=" + valuePoint.getX() + " Y= " + valuePoint.getY(), e);

    }

  public Geometry finish() throws FinishServiceException {

    Point geometry = null;

    try {

      geometry = editingProviderServices.createPoint(valuePoint.getX(),

          valuePoint.getY(), featureStore);

    }

    catch (Exception e) {

      throw new FinishServiceException("Can't finalize " + this.getName()

          + "with X=" + valuePoint.getX() + " Y= " + valuePoint.getY(), e);

    }

    return geometry;

  }

import org.gvsig.fmap.geom.Geometry;

   * and return geometry created.

   * @return Geometry created.

  public Geometry finish() throws FinishServiceException;

  /**

   * 

   * @throws FinishServiceException

   */

  public void finishAndStore () throws FinishServiceException;

  public FinishServiceException(String message, Throwable ex){

    super(message, ex, KEY, serialVersionUID);

  }

import org.gvsig.fmap.geom.Geometry;

   * and return geometry created.

   * @return Geometry created.

  public Geometry finish() throws FinishServiceException;

   * 

   * @throws FinishServiceException

   */

  public void finishAndStore () throws FinishServiceException;

  /**

import java.util.Stack;

import org.gvsig.vectorediting.lib.api.exceptions.FinishServiceException;

  private static final Logger logger = LoggerFactory

      .getLogger(DefaultEditingBehavior.class);

  private Map<FLyrVect, EditingService> serviceRegistration;

  private Stack<EditingService> serviceStack;

  private MapControl mapControl;

  private FLyrVect currentLayer;

  private FeatureStore featureStore;

  private EditingServiceParameter currentParam;

  private Point adjustedPoint;

  // private StatusBarListener sbl = null;

  private JConsole console;

  private JDockPanel dockConsole = null;

  private boolean isShowConsole;

  protected ResponseAdapter consoleResponseAdapter;

  private I18nManager i18nManager = ToolsLocator.getI18nManager();

  private EditingCompoundBehavior compoundBehavior;

  private static final Image imageCursor = new BufferedImage(32, 32,

      BufferedImage.TYPE_INT_ARGB);

  static {

    Graphics g = imageCursor.getGraphics();

    int size1 = 15;

    int x = 16;

    int y = 16;

    g.setColor(Color.MAGENTA);

    g.drawLine((x - size1), (y), (x + size1), (y));

    g.drawLine((x), (y - size1), (x), (y + size1));

    g.drawRect((x - 6), (y - 6), 12, 12);

    g.drawRect((x - 3), (y - 3), 6, 6);

  }

  private LayerListener layerListener = new LayerListener() {

    public void activationChanged(LayerEvent e) {

      FLayer layer = e.getSource();

      if (layer instanceof FLyrVect) {

        if (layer.isActive() && layer.isEditing()) {

          showConsole();

          getMapControl().setTool("VectorEditing");

        }

        else if (!layer.isEditing() && layer.isActive()) {

          // try{

          // // changeCurrentLayer((FLyrVect) layer);

          // }

          // catch (ChangeCurrentLayerException e1) {

          // //TODO Auto-generated catch block

          // e1.printStackTrace();

          // }

          hideConsole();

          getMapControl().setTool("zoomIn");

        }

        try {

          changeCurrentLayer((FLyrVect) layer);

        }

        catch (ChangeCurrentLayerException e1) {

          // TODO Auto-generated catch block

          e1.printStackTrace();

        }

      }

    }

    public void drawValueChanged(LayerEvent e) {}

    public void editionChanged(LayerEvent e) {}

    public void nameChanged(LayerEvent e) {}

    public void visibilityChanged(LayerEvent e) {}

  };

  public void cleanBehavior() {

    serviceStack.clear();

    currentParam = null;

    this.enableSelection(false);

    showConsoleMessage("\n" + i18nManager.getTranslation("select_new_tool")

        + "\n");

  }

  public DefaultEditingBehavior(MapControl mapControl)

      throws CreateEditingBehaviorException {

    if (mapControl != null) {

      this.mapControl = mapControl;

      serviceRegistration = new HashMap<FLyrVect, EditingService>();

      serviceStack = new Stack<EditingService>();

      // sbl = new StatusBarListener(mapControl);

      initMapControlListeners(mapControl);

      initConsolePanelListeners(getConsolePanel());

      FLayers layers = mapControl.getMapContext().getLayers();

      for (int i = 0; i < layers.getLayersCount(); i++) {

        if (layers.getLayer(i) instanceof FLyrVect

            && layers.getLayer(i).isActive()) try {

          changeCurrentLayer((FLyrVect) layers.getLayer(i));

        }

        catch (ChangeCurrentLayerException e) {

          throw new CreateEditingBehaviorException(e);

        }

      }

    }

  }

  private void initConsolePanelListeners(JConsole jConsole) {

    consoleResponseAdapter = new ResponseAdapter();

    jConsole.addResponseListener(consoleResponseAdapter);

    addConsoleListener("ViewEditing", new ResponseListener() {

      public void acceptResponse(String response) {

        try {

          textEntered(response);

        }

        catch (InvalidEntryException e) {

          showConsoleMessage(i18nManager.getTranslation("invalid_option"));

        }

        catch (StopServiceException e) {

          logger.error(i18nManager.getTranslation("cant_stop_the_service")

              + " " + getActiveService().getName(), e);

        }

        finally {

          if (getActiveService() != null) {

            getNextParameter();

          }

        }

      }

    });

  }

    EditingManager manager = EditingLocator.getManager();

    if (currentLayer != null) {

      EditingService service = serviceRegistration.get(currentLayer);

      if (service == null || !service.getName().equals(name)) {

        service = (EditingService) manager.getEditingService(name,

            currentLayer.getFeatureStore());

        serviceRegistration.put(currentLayer, service);

      }

      if (service != null) {

        this.enableSelection(false);

        try {

          service.start();

        }

        catch (StartServiceException e) {

          logger.error(

              String.format("Can't start the service %(s)", service.getName()),

              e);

        }

        if (serviceStack.isEmpty()

            || getActiveService().next().getTypes()

                .contains(EditingServiceParameter.TYPE.GEOMETRY)) {

          setActiveService(service);

        }

        else {

          serviceStack.clear();

          setActiveService(service);

        }

        getNextParameter();

      }

    }

  }

  private void askQuestion(EditingServiceParameter param) {

    if (getConsolePanel() != null) {

      showConsoleMessage("\n#" + param.getDescription() + " > ");

    }

  }

  private void showConsoleMessage(String text) {

    getConsolePanel().addText(text, JConsole.MESSAGE);

  }

  @Override

  public ToolListener getListener() {

    return new ToolListener() {

      /**

      public boolean cancelDrawing() {

        return false;

      }

      /**

      public Image getImageCursor() {

        return imageCursor;

      }

    };

  }

  private void getNextParameter() {

    currentParam = getActiveService().next();

    if (currentParam == null) {

      finishService();

    }

    else {

      askQuestion(currentParam);

      if (currentParam.getTypes().contains(

          EditingServiceParameter.TYPE.SELECTION)) {

        enableSelection(true);

      }

      setCaretPosition();

    }

  }

  private EditingService getActiveService() {

    if (!serviceStack.isEmpty()) {

      return serviceStack.peek();

    }

    return null;

  }

  private void setActiveService(EditingService service) {

    serviceStack.add(service);

  }

  private void initMapControlListeners(MapControl mapControl) {

    MapContext context = mapControl.getMapContext();

    FLayers layers = context.getLayers();

    layers.addLayerListener(layerListener);

    layers.addLayerCollectionListener(new LayerCollectionListener() {

      public void layerAdded(LayerCollectionEvent e) {

        FLayers layers2 = e.getLayers();

        for (int i = 0; i < layers2.getLayersCount(); i++) {

          FLayer layer = layers2.getLayer(i);

          if (layer instanceof FLyrVect) {

            ((FLyrVect) layer).addLayerListener(layerListener);

          }

        }

      }

      public void layerAdding(LayerCollectionEvent e)

          throws CancelationException {}

      public void layerMoved(LayerPositionEvent e) {}

      public void layerMoving(LayerPositionEvent e) throws CancelationException {}

      public void layerRemoved(LayerCollectionEvent e) {

        FLayers layers2 = e.getLayers();

        for (int i = 0; i < layers2.getLayersCount(); i++) {

          FLayer layer = layers2.getLayer(i);

          if (layer instanceof FLyrVect) {

            ((FLyrVect) layer).removeLayerListener(layerListener);

          }

        }

      }

      public void layerRemoving(LayerCollectionEvent e)

          throws CancelationException {}

      public void visibilityChanged(LayerCollectionEvent e)

          throws CancelationException {}

    });

  }

  public void mouseClicked(MouseEvent e) {

    ViewPort vp = mapControl.getViewPort();

    if (getActiveService() != null) {

      if (currentParam != null) {

        List<TYPE> typesOfParam = currentParam.getTypes();

        if (typesOfParam.contains(TYPE.LIST_POSITIONS)) {

          if (e.getClickCount() == 2) {

            finishService();

            return;

          }

          Point point;

          point = vp.convertToMapPoint(e.getX(), e.getY());

          try {

            getActiveService().value(point);

          }

          catch (VectorEditingException ex) {

            logger.error("Invalid value %s", new Object[] { point });

          }

        }

        if (typesOfParam.contains(TYPE.POSITION)) {

          Point point;

          point = vp.convertToMapPoint(e.getX(), e.getY());

          try {

            getActiveService().value(point);

          }

          catch (VectorEditingException ex) {

            logger.error("Invalid value %s", new Object[] { point });

          }

        }

        if (typesOfParam.contains(TYPE.SELECTION)) {

          // Do nothing

        }

        getNextParameter();

      }

    }

  }

  private void finishService() {

    EditingService lastService = serviceStack.pop();

    try {

      if (serviceStack.isEmpty()) {

        lastService.finishAndStore();

        mapControl.rePaintDirtyLayers();

        setActiveService(lastService);

      }

      else if (getActiveService().next().getTypes()

          .contains(EditingServiceParameter.TYPE.GEOMETRY)) {

        Object geometry = lastService.finish();

        getActiveService().value(geometry);

      }

      lastService.stop();

      lastService.start();

    }

    catch (InvalidEntryException ex) {

      showConsoleMessage(i18nManager.getTranslation("invalid_option"));

    }

    catch (FinishServiceException ex) {

      logger.error("", ex);

    }

    catch (StopServiceException ex) {

      logger.error("", ex);

    }

    catch (StartServiceException ex) {

      logger.error("", ex);

    }

    getNextParameter();

  }

  public void mouseEntered(MouseEvent e) throws BehaviorException {}

  public void mouseMoved(MouseEvent e) throws BehaviorException {

    ViewPort vp = mapControl.getViewPort();

    adjustedPoint = vp.convertToMapPoint(e.getX(), e.getY());

    // showCoords(e.getPoint());

    getMapControl().repaint();

  }

  public void mousePressed(MouseEvent e) throws BehaviorException {}

  public void mouseReleased(MouseEvent e) throws BehaviorException {}

  public void paintComponent(MapControlDrawer mapControlDrawer) {

    super.paintComponent(mapControlDrawer);

    if (getActiveService() == null || adjustedPoint == null) {

      return;

    }

    DrawingStatus helperGeo = null;

    try {

      helperGeo = getActiveService().draw(adjustedPoint);

    }

    catch (VectorEditingException e) {

      logger.error("An error ocurred when draw service geometries", e);

    }

    if (helperGeo != null) {

          .hasNext();) {

        Geometry geometry = (Geometry) iterator.next();

        mapControl.getMapControlDrawer().draw(geometry,

            MapControlLocator.getMapControlManager().getAxisReferenceSymbol());

      }

    }

  }

  private void setCaretPosition() {

    JEditTextArea jeta = getConsolePanel().getTxt();

    jeta.requestFocusInWindow();

    jeta.setCaretPosition(jeta.getText().length());