Application: gvSIG desktop » gvSIG tools: Vector editing

/*

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

 *

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

 * SVN Id   : $Id$

 */

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

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

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryManager;

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

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

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

import org.gvsig.fmap.geom.operation.GeometryOperationException;

import org.gvsig.fmap.geom.operation.GeometryOperationNotSupportedException;

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

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

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

import org.gvsig.tools.dynobject.DynObject;

import org.gvsig.tools.exception.BaseException;

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

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

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

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

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

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;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

public class CircleCREditingProvider extends AbstractEditingProvider implements

    EditingProvider {

  private static final Logger logger = LoggerFactory

      .getLogger(CircleCREditingProvider.class);

  protected GeometryManager geomManager = GeometryLocator.getGeometryManager();

  private EditingServiceParameter center = new DefaultEditingServiceParameter(

      "Center", "Center position of circle", TYPE.POSITION);

  private EditingServiceParameter radius = new DefaultEditingServiceParameter(

      "Radius", "Radius of circle", TYPE.POSITION, TYPE.VALUE);

  private Map<EditingServiceParameter, Object> values;

  private FeatureStore featureStore;

  public CircleCREditingProvider(ProviderServices providerServices,

      DynObject parameters) {

    super(providerServices);

    this.featureStore = (FeatureStore) parameters

        .getDynValue(EditingProviderFactory.FEATURE_STORE_FIELD);

  }

  public DefaultDrawingStatus draw(Point mousePosition) throws BaseException {

    DefaultDrawingStatus geometries = new DefaultDrawingStatus();

    if (values.get(center) != null) {

      Point centerPoint = (Point) values.get(center);

      Curve line = ((EditingProviderServices) getProviderServices())

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

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

      Arc circle = ((EditingProviderServices) getProviderServices()).createArc(

          centerPoint, mousePosition.distance(centerPoint), 0, 2 * Math.PI,

          featureStore);

      geometries.addGeometry(circle);

      geometries.addGeometry(centerPoint);

      geometries.addGeometry(line);

      return geometries;

    }

    return null;

  }

  public EditingServiceParameter next() {

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

      return this.center;

    }

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

      return this.radius;

    }

    return null;

  }

  public void stop() {

  }

  private void validateAndInsertValue(EditingServiceParameter param,

                                      Object value) {

    if (param == center) {

      if (value instanceof Point) {

        values.put(param, value);

        return;

      }

    }

    else if (param == radius) {

      if (value instanceof Point) {

        Double radiusValue = null;

        try {

          radiusValue = ((Point) value).distance((Point) values.get(center));

        }

        catch (GeometryOperationNotSupportedException e) {

          logger.warn("Can't calculate the radius", e);

        }

        catch (GeometryOperationException e) {

          logger.warn("Can't calculate the radius", e);

        }

        if (radiusValue != null) {

          values.put(param, radiusValue);

        }

      }

      else if (value instanceof Double) {

        values.put(param, value);

      }

      else if (value instanceof String) {

        // FIXME: el string podr?a ser tambi?n un punto

        Double.parseDouble((String) value);

        values.put(param, value);

      }

    }

  }

  public List<EditingServiceParameter> getParameters() {

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

    list.add(center);

    list.add(radius);

    return list;

  }

  public void value(Object value) {

    EditingServiceParameter param = next();

    validateAndInsertValue(param, value);

  }

  public void finish() throws CreateGeometryException, DataException {

    Point centerPoint = (Point) values.get(center);

    double radiusValue = (Double) values.get(radius);

    EditingProviderServices editingProviderServices = (EditingProviderServices)

        getProviderServices();

    GeometryType storeGeomType = editingProviderServices

        .getGeomType(featureStore);

    Geometry geometry = null;

    if (storeGeomType.isTypeOf(SURFACE)) {

      geometry = editingProviderServices.createCircle(centerPoint, radiusValue,

          featureStore);

      editingProviderServices.insertGeometryIntoFeatureStore(geometry,

          featureStore);

    }

    else if (storeGeomType.isTypeOf(CURVE)) {

      geometry = editingProviderServices.createArc(centerPoint, radiusValue, 0,

          2 * Math.PI, featureStore);

      editingProviderServices.insertGeometryIntoFeatureStore(geometry,

          featureStore);

    }

    else if (storeGeomType.isTypeOf(MULTISURFACE)) {

      geometry = editingProviderServices.createCircle(centerPoint, radiusValue,

          featureStore);

      MultiSurface multisurface;

      multisurface = geomManager.createMultiSurface(storeGeomType.getSubType());

      multisurface.addSurface((Circle) geometry);

      editingProviderServices.insertGeometryIntoFeatureStore(multisurface,

          featureStore);

    }

    else if (storeGeomType.isTypeOf(MULTICURVE)) {

      geometry = editingProviderServices.createArc(centerPoint, radiusValue, 0,

          2 * Math.PI, featureStore);

      MultiCurve multicurve;

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

      multicurve.addCurve((Arc) geometry);

      editingProviderServices.insertGeometryIntoFeatureStore(multicurve,

          featureStore);

    }

    else {

      editingProviderServices.insertGeometryIntoFeatureStore(geometry,

          featureStore);

    }

  }

  public void start() {

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

  }

  public String getName() {

    return CircleCREditingProviderFactory.PROVIDER_NAME;

  }

}