Application: gvSIG desktop » gvSIG tools: Vector editing

/*

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

 * 

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

 * SVN Id   : $Id$

 */

package org.gvsig.vectorediting.swing.impl;

import java.awt.BorderLayout;

import java.awt.Component;

import org.gvsig.editing.EditingNotification;

import org.gvsig.editing.EditingNotificationManager;

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

import org.gvsig.fmap.mapcontext.MapContext;

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

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

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

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

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

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

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

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

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

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

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

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

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

public class DefaultEditingContext implements EditingContext {

  private static final Logger logger = LoggerFactory

      .getLogger(EditingManager.class);

  private MapControl mapControl;

  private EditingCompoundBehavior editingCompoundBehavior;

  private JConsole console;

  private JDockPanel dockConsole = null;

  private boolean isShowConsole = false;

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

          hideConsole();

          getMapControl().setTool("zoomIn");

        }

        getEditingBehavior().changeCurrentLayer((FLyrVect) layer);

      }

    }

    public void drawValueChanged(LayerEvent e) {}

    public void editionChanged(LayerEvent e) {}

    public void nameChanged(LayerEvent e) {}

    public void visibilityChanged(LayerEvent e) {}

  };

  public DefaultEditingContext(MapControl mapControl) {

    this.mapControl = mapControl;

    initMapControlListeners();

    initConsolePanelListeners(getConsolePanel());

  }

  public void activateService(String name) {

    if (mapControl != null && mapControl.hasTool("VectorEditing")) {

      CompoundBehavior editingCompoundBehavior = getEditingCompoundBehavior();

      mapControl.setTool("VectorEditing");

//      EditingBehavior editingBehavior = (EditingBehavior) editingCompoundBehavior

//          .getBehavior(EditingCompoundBehavior.EDITING_INDEX);

      EditingBehavior editingBehavior = getEditingBehavior();

      editingCompoundBehavior.setDrawnBehavior(

          EditingCompoundBehavior.EDITING_INDEX, true);

      editingBehavior.activateService(name);

    }

  }

  public void beginEdition(FLyrVect layer, Behavior[] additionalBehaviors) {

    EditingNotificationManager editingNotificationManager = MapControlLocator

        .getEditingNotificationManager();

    EditingNotification notification = editingNotificationManager

        .notifyObservers(this, EditingNotification.BEFORE_ENTER_EDITING_STORE,

            null, layer);

    if (notification.isCanceled()) {

      logger.info("Edit layer '" + layer.getName()

          + "' canceled by somme observer.", new StartEditingException(

          "Edit layer '" + layer.getName() + "' canceled.", null));

    }

    try {

      addBehaviors(additionalBehaviors);

    }

    catch (CreateEditingBehaviorException e1) {

      logger.error(e1.getMessage(), e1);

    }

    try {

      layer.getFeatureStore().edit();

    }

    catch (Exception e) {

      logger.error("Can't set featureStore in edit mode",

          new VectorEditingException(e));

    }

    // layer.getFeatureStore().addObserver(view);

    layer.getFeatureStore().addObserver(mapControl);

    editingNotificationManager.notifyObservers(this,

        EditingNotification.AFTER_ENTER_EDITING_STORE, null, layer);

  }

  private void addBehaviors(Behavior[] additionalBehavior)

      throws CreateEditingBehaviorException {

    EditingBehavior editingBehavior;

    EditingCompoundBehavior editingCompoundBehavior;

    if (!mapControl.hasTool("VectorEditing")) {

      editingBehavior = new DefaultEditingBehavior(this);

      editingCompoundBehavior = new EditingCompoundBehavior(editingBehavior);

      setCompoundBehavior(editingCompoundBehavior);

      if (additionalBehavior != null) {

        Behavior[] behaviors = new Behavior[additionalBehavior.length + 1];

        behaviors[0] = editingCompoundBehavior;

        for (int i = 0; i < additionalBehavior.length; i++) {

          behaviors[i + 1] = additionalBehavior[i];

        }

        mapControl.addBehavior("VectorEditing", behaviors);

      }

      else {

        mapControl.addBehavior("VectorEditing", editingCompoundBehavior);

      }

    }

    else {

      editingCompoundBehavior = getEditingCompoundBehavior();

      editingBehavior = (EditingBehavior) editingCompoundBehavior

          .getBehavior(EditingCompoundBehavior.EDITING_INDEX);

      setCompoundBehavior(editingCompoundBehavior);

      editingBehavior.cleanBehavior();

    }

    mapControl.setTool("VectorEditing");

    showConsole();

  }

  private void discardChanges(FLyrVect layer) throws EndEditingException {

    FeatureStore featureStore = layer.getFeatureStore();

    try {

      featureStore.cancelEditing();

      EditingBehavior editingBehavior = getEditingBehavior();

      editingBehavior.cleanBehavior();

      hideConsole();

    }

    catch (Exception e) {

      throw new EndEditingException(e);

    }

    featureStore.deleteObserver(mapControl);

  }

  private void doAction(FLyrVect layer, int option) {

    switch (option) {

      case SAVE_CHANGES:

        try {

          saveChanges(layer);

        }

        catch (VectorEditingException e) {

          logger.error("Changes can not be saved in " + layer.getName(), e);

        }

        break;

      case DISCARD_CHANGES:

        try {

          discardChanges(layer);

        }

        catch (VectorEditingException e) {

          logger.error("Changes can not be discared in " + layer.getName(), e);

        }

        break;

      case EXPORT_LAYER:

        try {

          exportLayer(layer);

        }

        catch (VectorEditingException e) {

          logger.error("Changes can not be imported", e);

        }

        break;

      case CANCEL:

        break;

    }

  }

  public void enableSelection(boolean enableSelection) {

    this.editingCompoundBehavior.setDrawnBehavior(

        EditingCompoundBehavior.SELECTION_INDEX, enableSelection);

  }

  public void endEdition(FLyrVect layer) {

    if (layer.isEditing()) {

      EditingNotificationManager editingNotificationManager = MapControlLocator

          .getEditingNotificationManager();

      EditingNotification notification = editingNotificationManager

          .notifyObservers(this, EditingNotification.BEFORE_EXIT_EDITING_STORE,

              null, layer);

      if (notification.isCanceled()) {

        logger.info("Stop edit layer '" + layer.getName()

            + "' canceled by somme observer.", new EndEditingException(

            "Stop edit layer '" + layer.getName() + "' canceled.", null));

      }

      mapControl.getCanceldraw().setCanceled(true);

      int option;

      EditingSwingManager swingManager = EditingSwingLocator.getSwingManager();

      if (layer.isWritable()) {

        option = swingManager.showPanelSaveOrDiscard(mapControl,

            layer.getName());

      }

      else {

        option = swingManager.showPanelExportOrDiscard(mapControl,

            layer.getName());

      }

      doAction(layer, option);

      editingNotificationManager.notifyObservers(this,

          EditingNotification.AFTER_EXIT_EDITING_STORE, null, layer);

    }

  }

  private void exportLayer(FLyrVect layer) throws EndEditingException {

    // TODO Auto-generated method stub

  }

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

    if (dockConsole == null) {

      dockConsole = new JDockPanel(getConsolePanel());

    }

    return dockConsole;

  }

  private EditingBehavior getEditingBehavior() {

    return (EditingBehavior) editingCompoundBehavior

        .getBehavior(EditingCompoundBehavior.EDITING_INDEX);

  }

  private EditingCompoundBehavior getEditingCompoundBehavior() {

    if (editingCompoundBehavior != null) {

      return editingCompoundBehavior;

    }

    else {

      EditingCompoundBehavior editingCompoundBehavior;

      CompoundBehavior compoundBehavior = (CompoundBehavior) mapControl

          .getMapTool("VectorEditing");

      if (compoundBehavior instanceof EditingCompoundBehavior) {

        editingCompoundBehavior = (EditingCompoundBehavior) compoundBehavior;

      }

      else {

        editingCompoundBehavior = (EditingCompoundBehavior) compoundBehavior

            .getBehavior(0);

      }

      setCompoundBehavior(editingCompoundBehavior);

      return editingCompoundBehavior;

    }

  }

  public MapControl getMapControl() {

    return this.mapControl;

  }

  /**

   * Hides editing console.

   */

  private void hideConsole() {

    isShowConsole = false;

    getDockConsole().setVisible(false);

  }

  private void initConsolePanelListeners(JConsole jConsole) {

    jConsole.addResponseListener(new ResponseListener() {

      public void acceptResponse(String response) {

        getEditingBehavior().textEntered(response);

      }

    });

  }

  private void initMapControlListeners() {

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

    });

  }

  private void saveChanges(FLyrVect layer) throws EndEditingException {

    FeatureStore featureStore = layer.getFeatureStore();

    try {

      featureStore.finishEditing();

      EditingBehavior editingBehavior = getEditingBehavior();

//      EditingCompoundBehavior editingCompoundBehavior;

//      editingCompoundBehavior = (EditingCompoundBehavior) mapControl

//          .getMapTool("VectorEditing");

//      editingBehavior = (EditingBehavior) editingCompoundBehavior

//          .getBehavior(EditingCompoundBehavior.EDITING_INDEX);

      editingBehavior.cleanBehavior();

      hideConsole();

    }

    catch (Exception e) {

      throw new EndEditingException(e);

    }

    featureStore.deleteObserver(mapControl);

  }

  private void setCaretPosition() {

    JEditTextArea jeta = getConsolePanel().getTxt();

    jeta.requestFocusInWindow();

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

  }

  public void setCompoundBehavior(EditingCompoundBehavior compoundBehavior) {

    this.editingCompoundBehavior = compoundBehavior;

  }

  /**

   * Shows editing console.

   */

  private 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 showConsoleMessage(String text) {

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

  }

}