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

import java.awt.Color;

import java.awt.Graphics;

import java.awt.Image;

import java.awt.event.MouseEvent;

import java.awt.geom.Point2D;

import java.awt.image.BufferedImage;

import java.util.HashMap;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import org.cresques.cts.IProjection;

import org.gvsig.andami.PluginServices;

import org.gvsig.andami.ui.mdiFrame.MainFrame;

import org.gvsig.app.extension.CheckSOAndArquitectureExtension.ShowMessageControler;

import org.gvsig.app.project.documents.view.toolListeners.StatusBarListener;

import org.gvsig.fmap.geom.Geometry;

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

import org.gvsig.fmap.mapcontext.MapContext;

import org.gvsig.fmap.mapcontext.ViewPort;

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

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

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

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

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

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

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

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

import org.gvsig.fmap.mapcontext.layers.vectorial.FLyrVect;

import org.gvsig.fmap.mapcontrol.MapControl;

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.utils.console.JConsole;

import org.gvsig.utils.console.JDockPanel;

import org.gvsig.utils.console.ResponseListener;

import org.gvsig.utils.console.jedit.JEditTextArea;

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

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

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

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

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

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 MapControl mapControl;

  private FLyrVect currentLayer;

  private EditingService activeService;

  private EditingServiceParameter currentParam;

  private Point adjustedPoint;

  private StatusBarListener sbl = null;

  private JConsole console;

  private JDockPanel dockConsole = null;

  private boolean isShowConsole;

  protected ResponseAdapter consoleResponseAdapter;

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

          changeCurrentLayer((FLyrVect) layer);

          hideConsole();

          getMapControl().setTool("zoomIn");

        }

        changeCurrentLayer((FLyrVect) layer);

      }

    }

    public void drawValueChanged(LayerEvent e) {}

    public void editionChanged(LayerEvent e) {}

    public void nameChanged(LayerEvent e) {}

    public void visibilityChanged(LayerEvent e) {}

  };

  public void cleanBehavior() {

    activeService = null;

    currentParam = null;

    showConsoleMessage("\nSeleccione una herramienta\n");

    // MainFrame main = PluginServices.getMainFrame();

    // main.setSelectedTool(""); We can define a default tool. I.E Zoom in.

  }

  public DefaultEditingBehavior(MapControl mapControl) {

    if (mapControl != null) {

      this.mapControl = mapControl;

      serviceRegistration = new HashMap<FLyrVect, 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())

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

      }

    }

  }

  private void initConsolePanelListeners(JConsole jConsole) {

    consoleResponseAdapter = new ResponseAdapter();

    jConsole.addResponseListener(consoleResponseAdapter);

    addConsoleListener("ViewEditing", new ResponseListener() {

      public void acceptResponse(String response) {

        try{

          textEntered(response);

        } catch( VectorEditingException e){

          showConsoleMessage(e.getMessage());

        } finally{

          getNextParameter();

        }

      }

    });

  }

  public void activateTool(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.activeService = service;

        service.start();

        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 = activeService.next();

    if (currentParam == null) {

      finishAndStartService();

      getNextParameter();

    }

    else {

      askQuestion(currentParam);

      setCaretPosition();

    }

  }

  private void finishAndStartService() {

    try {

      activeService.finish();

    }

    catch (VectorEditingException e) {

      logger.error("An error ocurred when try to finish service", e);

    }

    mapControl.rePaintDirtyLayers();

    activeService.start();

  }

  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 (activeService != null) {

      if (currentParam != null) {

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

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

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

            finishAndStartService();

            return;

          }

          Point point;

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

          try {

            this.activeService.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 {

            this.activeService.value(point);

          }

          catch (VectorEditingException ex) {

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

          }

          // TODO: Comprobar el resto de casos:

          // TYPE.VALUE,

          // TYPE.OPTION, TYPE.SELECTION,

          // TYPE.GEOMETRY:

        }

        getNextParameter();

      }

    }

  }

  public void mouseEntered(MouseEvent e) throws BehaviorException {

    // TODO Auto-generated method stub

  }

  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 {

    // TODO Auto-generated method stub

  }

  public void mouseReleased(MouseEvent e) throws BehaviorException {

    // TODO Auto-generated method stub

  }

  public void paintComponent(MapControlDrawer mapControlDrawer) {

    super.paintComponent(mapControlDrawer);

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

      return;

    }

    DrawingStatus helperGeo = null;

    try {

      helperGeo = activeService.draw(adjustedPoint);

    }

    catch (VectorEditingException e) {

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

    }

    if (helperGeo != null) {

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

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

  }

  private void changeCurrentLayer(FLyrVect layer) {

    this.currentLayer = layer;

    this.activeService = serviceRegistration.get(layer);

    if (activeService != null) {

      getNextParameter();

      MainFrame main = PluginServices.getMainFrame();

      main.setSelectedTool(activeService.getName());

    }

  }

  private void showCoords(Point2D point) {

    String[] axisText = new String[2];

    axisText[0] = "X = ";

    axisText[1] = "Y = ";

    ViewPort vp = mapControl.getMapContext().getViewPort();

    IProjection iProj = vp.getProjection();

    Point p = vp.convertToMapPoint(point);

    Point2D p2D = new Point2D.Double(p.getX(), p.getY());

    sbl.setFractionDigits(p2D);

    axisText = sbl.setCoorDisplayText(axisText);

    MainFrame mF = PluginServices.getMainFrame();

    if (mF != null) {

      mF.getStatusBar().setMessage(

          "units",

          PluginServices.getText(this,

              MapContext.getDistanceNames()[vp.getDistanceUnits()]));

      mF.getStatusBar().setControlValue("scale",

          String.valueOf(mapControl.getMapContext().getScaleView()));

      mF.getStatusBar().setMessage("projection", iProj.getAbrev());

      String[] coords = sbl.getCoords(p2D);

      mF.getStatusBar().setMessage("x", axisText[0] + coords[0]);

      mF.getStatusBar().setMessage("y", axisText[1] + coords[1]);

    }

  }

  private void textEntered(String response) throws InvalidEntryException{

    if (response == null) {

      this.activeService.stop();

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

            this.activeService.value(point);

            insertedValue = true;

          }

        }

        catch (VectorEditingException e) {

          // Do nothing

        }

      }

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

        try {

          value = parseValue(response);

          if (value != null) {

            this.activeService.value(value);

            insertedValue = true;

          }

        }

        catch (VectorEditingException e) {

          // Do nothing

        }

      }

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

        try {

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

          if (response != null) {

            this.activeService.value(response);

            insertedValue = true;

          }

        }

        catch (VectorEditingException e) {

          // Do nothing

        }

      }

      // TODO: contemplar el resto de casos

      // TYPE.OPTION,

      // TYPE.SELECTION,

      // TYPE.GEOMETRY

      if (!insertedValue) {

        throw new InvalidEntryException(null);

      }

    }

  }

  private Double parseValue(String response) throws ParseValueException {

    try {

      return Double.valueOf(response);

    }

    catch (Exception e) {

      throw new ParseValueException(e);

    }

  }

  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 JDockPanel getDockConsole() {

    if (dockConsole == null) {

      dockConsole = new JDockPanel(getConsolePanel());

    }

    return dockConsole;

  }

  public void showConsole() {

    if (isShowConsole) {

      return;

    }

    isShowConsole = true;

    getMapControl().remove(getDockConsole());

    getMapControl().setLayout(new BorderLayout());

    getMapControl().add(getDockConsole(), BorderLayout.SOUTH);

    getDockConsole().setVisible(true);

    setCaretPosition();

  }

  public void hideConsole() {

    isShowConsole = false;

    getDockConsole().setVisible(false);

  }

  private JConsole getConsolePanel() {

    if (console == null) {

      console = new JConsole(true);

      // Para distinguir cuando se est? escribiendo sobre la consola y

      // cuando no.

      console.setJTextName("VectorEditingConsole");

    }

    return console;

  }

  private void addConsoleListener(String prefix, ResponseListener listener) {

    consoleResponseAdapter.putSpaceListener(prefix, listener);

  }

  static class ResponseAdapter implements ResponseListener {

    private HashMap<String, ResponseListener> spaceListener = new HashMap<String, ResponseListener>();

    public void putSpaceListener(String namespace, ResponseListener listener) {

      spaceListener.put(namespace, listener);

    }

    public void acceptResponse(String response) {

      boolean nameSpace = false;

      int n = -1;

      if (response != null) {

        if ((n = response.indexOf(':')) != -1) {

          nameSpace = true;

        }

      }

      if (nameSpace) {

        ResponseListener listener = spaceListener.get(response.substring(0, n));

        if (listener != null) {

          listener.acceptResponse(response.substring(n + 1));

        }

      }

      else {

        Iterator<ResponseListener> i = spaceListener.values().iterator();

        while (i.hasNext()) {

          ResponseListener listener = i.next();

          listener.acceptResponse(response);

        }

      }

    }

  }

}