Application: gvSIG desktop » gvSIG tools: Vector editing

/*

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

 *

 * Project  : DiSiD org.gvsig.vectorediting.lib.impl

 * SVN Id   : $Id$

 */

package org.gvsig.vectorediting.swing.impl;

import java.awt.Color;

import java.awt.Graphics;

import java.awt.Image;

import java.awt.event.MouseEvent;

import java.awt.image.BufferedImage;

import java.util.HashMap;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import java.util.Stack;

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

import org.gvsig.fmap.geom.Geometry;

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

import org.gvsig.fmap.mapcontext.ViewPort;

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

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.tools.BehaviorException;

import org.gvsig.fmap.mapcontrol.tools.Behavior.Behavior;

import org.gvsig.fmap.mapcontrol.tools.Listeners.ToolListener;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.i18n.I18nManager;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

import org.gvsig.vectorediting.swing.api.EditingBehavior;

import org.gvsig.vectorediting.swing.api.EditingContext;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

public class DefaultEditingBehavior extends Behavior implements EditingBehavior {

  private static final Logger logger = LoggerFactory

      .getLogger(DefaultEditingBehavior.class);

  private Map<FLyrVect, EditingService> serviceRegistration;

  private Stack<EditingService> serviceStack;

  private EditingContext editingContext;

  private FLyrVect currentLayer;

  private EditingServiceParameter currentParam;

  private FeatureStore featureStore;

  private Point adjustedPoint;

  private I18nManager i18nManager = ToolsLocator.getI18nManager();

  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);

  }

  public DefaultEditingBehavior(EditingContext editingContext) throws CreateEditingBehaviorException {

    if (editingContext.getMapControl() != null) {

      this.editingContext = editingContext;

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

      serviceStack = new Stack<EditingService>();

      FLayers layers = editingContext.getMapControl().getMapContext().getLayers();

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

        if (layers.getLayer(i) instanceof FLyrVect

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

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

      }

    }

  }

  public void activateService(String name) {

    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();

      }

    }

  }

  /**

   * Shows description of parameter on console.

   */

  private void askQuestion(EditingServiceParameter param) {

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

  }

  public void cleanBehavior() {

    serviceStack.clear();

    currentParam = null;

    this.enableSelection(false);

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

        + "\n");

  }

  private void showConsoleMessage(String text) {

    editingContext.showConsoleMessage(text);

  }

  @Override

  public ToolListener getListener() {

    return new ToolListener() {

      /**

       *

       */

      public boolean cancelDrawing() {

        return false;

      }

      /**

       *

       */

      public Image getImageCursor() {

        return imageCursor;

      }

    };

  }

  /**

   * Gets next parameter of {@link #activateService(String)} and sets

   * {@link #currentParam}. If currentParam is null means all service parameters

   * have value and service doesn't need more values.

   */

  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 finishService() {

    EditingService lastService = serviceStack.pop();

    try {

      if (serviceStack.isEmpty() || !getActiveService().next().getTypes()

              .contains(EditingServiceParameter.TYPE.GEOMETRY)) {

        lastService.finishAndStore();

        editingContext.getMapControl().rePaintDirtyLayers();

        setActiveService(lastService);

      }

      else if (!serviceStack.isEmpty() && getActiveService().next().getTypes()

              .contains(EditingServiceParameter.TYPE.GEOMETRY)) {

        Geometry geometry = lastService.finish();

        if (geometry != null) {

          getActiveService().setValue(geometry);

        } else {

          lastService.finishAndStore();

          editingContext.getMapControl().rePaintDirtyLayers();

          setActiveService(lastService);

        }

      }

      lastService.stop();

      lastService.start();

    }

    catch (InvalidEntryException ex) {

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

    }

    catch (FinishServiceException ex) {

      logger.error("Can't finish " + lastService.getName(), ex);

    }

    catch (StopServiceException ex) {

      logger.error("Can't stop " + lastService.getName(), ex);

    }

    catch (StartServiceException ex) {

      logger.error("Can't start " + lastService.getName(), ex);

    }

    getNextParameter();

  }

  public void mouseClicked(MouseEvent e) {

    ViewPort vp = editingContext.getMapControl().getViewPort();

    if (getActiveService() != null) {

      if (currentParam != null) {

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

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

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

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

              finishService();

              return;

            }

          }

          Point point;

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

          try {

            getActiveService().setValue(point);

          }

          catch (VectorEditingException ex) {

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

          }

        }

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

          // Do nothing

        }

        getNextParameter();

      }

    }

  }

  public void mouseEntered(MouseEvent e) throws BehaviorException {}

  public void mouseMoved(MouseEvent e) throws BehaviorException {

    ViewPort vp = editingContext.getMapControl().getViewPort();

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

    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) {

      for (@SuppressWarnings("rawtypes")

      Iterator iterator = helperGeo.getGeometries().iterator(); iterator

          .hasNext();) {

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

        editingContext.getMapControl().getMapControlDrawer().draw(geometry,

            MapControlLocator.getMapControlManager().getAxisReferenceSymbol());

      }

    }

  }

  /**

   * Sets the layer received as parameter as {@link #currentLayer}

   * 

   * @param layer

   */

  public void changeCurrentLayer(FLyrVect layer) {

    this.currentLayer = layer;

    if (currentLayer != null) {

      this.featureStore = (FeatureStore) currentLayer.getFeatureStore();

    }

    serviceStack.clear();

    if (serviceRegistration.get(layer) != null) {

      setActiveService(serviceRegistration.get(layer));

    }

    if (getActiveService() != null && layer.isActive()) {

      getNextParameter();

    }

  }

  /**

   * Processes console entries from console. Tries to process entry in each type

   * of {@link #currentParam}. If there is some error, It will continue

   * checking. If entry has been processed, It will set value in

   * {@link #activeService}.

   * 

   * @param response Console entry.

   * @throws InvalidEntryException If console entries has not been able to

   *           process, it will throw an exception to indicate that entry is not

   *           valid.

   * @throws StopServiceException If there are some errors stopping service.

   */

  public void textEntered(String response) {

    if (response == null) {

      if (getActiveService() != null) {

        try {

          getActiveService().stop();

        }

        catch (StopServiceException e) {

          logger.error("Can't stop " + getActiveService().getName(), e);

        }

        cleanBehavior();

      }

    }

    else {

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

      Point point = null;

      Double value = null;

      boolean insertedValue = false;

      if (!insertedValue && types.contains(TYPE.POSITION)

          || types.contains(TYPE.LIST_POSITIONS)) {

        try {

          point = parsePoint(response);

          if (point != null) {

            getActiveService().setValue(point);

            insertedValue = true;

          }

        }

        catch (VectorEditingException e) {

          // Do nothing to try other types

        }

      }

      if (!insertedValue && types.contains(TYPE.VALUE)) {

        try {

          value = parseValue(response);

          if (value != null) {

            getActiveService().setValue(value);

            insertedValue = true;

          }

        }

        catch (VectorEditingException e) {

          // Do nothing to try other types

        }

      }

      if (!insertedValue && types.contains(TYPE.OPTION)) {

        try {

          response = response.replace("\n", "");

          if (response != null) {

            getActiveService().setValue(response);

            insertedValue = true;

          }

        }

        catch (VectorEditingException e) {

          // Do nothing to try other types

        }

      }

      if (!insertedValue && types.contains(TYPE.SELECTION)) {

        if (response.equalsIgnoreCase("\n")){

          enableSelection(false);

          insertedValue = true;

          try {

            getActiveService()

                .setValue(featureStore.getFeatureSelection().clone());

          }

          catch (InvalidEntryException e) {

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

          }

          catch (Exception e) {

            cleanBehavior();

            logger.error("Can't access to selecction.", e);

          }

        }

      }

      if (!insertedValue) {

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

      }

      getNextParameter();

    }

  }

  /**

   * Parse String to value.

   * 

   * @param response String to be parsed.

   * @return Values of string.

   * @throws ParseValueException If there is error trying to parse

   *           <code>String</code>.

   */

  private Double parseValue(String response) throws ParseValueException {

    try {

      return Double.valueOf(response);

    }

    catch (Exception e) {

      throw new ParseValueException(e);

    }

  }

  /**

   * Parse String to point. Formats accepted: (x,y) and x,y.

   * 

   * @param response String to be parsed.

   * @return Point of string.

   * @throws ParsePointException If there is error trying to parse

   *           <code>String</code>.

   */

  private Point parsePoint(String response) throws ParsePointException {

    String[] numbers = new String[1];

    numbers[0] = response;

    numbers = response.split(",");

    if (numbers.length == 2) {

      if (numbers[0].startsWith("(") && numbers[1].endsWith(")\n")) { // CCS

        numbers[0] = numbers[0].replace("(", "");

        numbers[1] = numbers[1].replace(")\n", "");

      }

      double[] values;

      try {

        values = new double[] { Double.parseDouble(numbers[0]),

            Double.parseDouble(numbers[1]) };

      }

      catch (Exception e) {

        throw new ParsePointException(e);

      }

      Point point;

      try {

        point = geomManager.createPoint(values[0], values[1], currentLayer

            .getFeatureStore().getDefaultFeatureType()

            .getDefaultGeometryAttribute().getGeomType().getSubType());

        // TODO: Maybe do util class to get type and subtype of a featureStore

        // or a method in manager

      }

      catch (Exception e) {

        throw new ParsePointException(e);

      }

      return point;

    }

    else {

      throw new ParsePointException(null);

    }

  }

  private void enableSelection(boolean enableSelection) {

     editingContext.enableSelection(enableSelection);

  }

}