Application: gvSIG desktop » gvSIG tools: Vector editing

import java.util.Collections;

import java.util.function.Predicate;

  private static final Logger LOGGER = LoggerFactory.getLogger(EditingExtension.class);

  @Override

  public void execute(String actionCommand) {

    ApplicationManager application = ApplicationLocator.getManager();

    IView view = getActiveView();

    EditingSwingManager swingManager = EditingSwingLocator.getSwingManager();

    if (view != null) {

      MapControl mapControl = view.getMapControl();

      EditingContext editingContext = swingManager.getEditingContext(mapControl);

      if ("start-editing".equals(actionCommand)) {

        List<FLyrVect> reprojectedLayers = getActiveLayers(

                view,

                (FLyrVect layer) -> canBeEdited(layer) && 

                        !mapControl.getProjection().equals(layer.getProjection())

        );

        if (!reprojectedLayers.isEmpty()) {

          String msg = "_The_layer_is_reproyected_on_the_fly"

                  + "_Not_all_editing_tools_work_properly"

                  + "_When_you_finish_editing"

                  + "_will_only_export_the_changes_to_another_layer";

          application.messageDialog(msg, "_Warning", JOptionPane.WARNING_MESSAGE);

        } else {

          List<FLyrVect> nonWritableLayers = getActiveLayers(

                  view,

                  (FLyrVect layer) -> canBeEdited(layer) && !isWritable(layer)

          );

          if (!nonWritableLayers.isEmpty()) {

            String msg = "_The_layer_can_not_be_written"

                    + "_When_you_finish_editing"

                    + "_will_only_export_the_changes_to_another_layer";

            application.messageDialog(msg, "_Warning", JOptionPane.WARNING_MESSAGE);

          }

        }

        List<FLyrVect> activeLayers = getActiveLayers(

                view,

                (FLyrVect layer) -> canBeEdited(layer)

        );

        for (FLyrVect layer : activeLayers) {

          editingContext.beginEdition(layer);

          editingContext.addObserver(this);

        }

        ApplicationLocator.getManager().refreshMenusAndToolBars();

      } else if ("end-editing".equals(actionCommand)) {

        List<FLyrVect> activeLayers = getActiveLayers(

                view,

                (FLyrVect layer) -> layer.isEditing()

        );

        for (FLyrVect layer : activeLayers) {

          editingContext.endEdition(layer);

        }

        ApplicationLocator.getManager().refreshMenusAndToolBars();

      }

  }

  @Override

  public void initialize() {

    registerIcons();

    // Disable default view panel console. Uses editing context console.

    DefaultViewPanel.setDisableConsole(true);

    // Adding TOC menu entry

    ExtensionPoint exPoint = ToolsLocator.getExtensionPointManager().add(

            "View_TocActions", "");

    exPoint.append(

            "TOC popup menu to start vector layer's editing",

            new StartEditingTocMenuEntry());

    exPoint.append(

            "TOC popup menu to end vector layer's editing",

            new EndEditingTocMenuEntry());

  }

  private void registerIcons() {

    IconThemeHelper.registerIcon("vectorediting", "vector-editing", this);

  }

  @Override

  public void postInitialize() {

    super.postInitialize();

    registerSymbols();

    MapControlLocator.getMapControlManager().addMapControlCreationListener(new MapControlCreationListener() {

      @Override

      public MapControl mapControlCreated(MapControl mapControl) {

        EditingContext editingContext = EditingSwingLocator.getSwingManager().getEditingContext(mapControl);

        StatusBarListener sbl = new StatusBarListener(mapControl);

        editingContext.setDefaultBehaviors(new Behavior[]{new MouseMovementBehavior(sbl)});

        editingContext.addObserver(EditingExtension.this);

        ApplicationLocator.getManager().refreshMenusAndToolBars();

        return mapControl;

      }

    });

  }

  /**

   * Register all symbols in the plugin symbols folder in the providerManager.

   * The description of the symbols must be unique because the key used for

   * registration is the proper description of the symbol.

   *

   */

  private void registerSymbols() {

    EditingProviderManager providerManager = EditingProviderLocator.getProviderManager();

    SymbolManager symbolManager = MapContextLocator.getSymbolManager();

    File symbolsFolder = FileUtils.getFile(getPlugin().getPluginDirectory(), "symbols", "editing");

    ISymbol[] symbols = null;

    try {

      symbols = symbolManager.loadSymbols(symbolsFolder);

    } catch (SymbolException e) {

      LOGGER.warn("No symbols loaded from " + symbolsFolder.getAbsolutePath(), e);

    if (symbols != null) {

      for (ISymbol symbol : symbols) {

        String description = symbol.getDescription();

        providerManager.registerSymbol(description, symbol);

      }

    }

  }

  @Override

  public boolean isEnabled() {

    return true;

  }

  @Override

  public boolean isVisible() {

    return true;

  }

  @Override

  public boolean isVisible(String action) {

    IView view = getActiveView();

    if( view == null ) {

      return false;

    if ("start-editing".equals(action)) {

      List<FLyrVect> activeLayers = getActiveLayers(view, (FLyrVect layer) -> !layer.isEditing());

      return !activeLayers.isEmpty();

    } else {

      List<FLyrVect> activeLayers = getActiveLayers(view, (FLyrVect layer) -> layer.isEditing());

      return !activeLayers.isEmpty();

  }

  @Override

  public boolean isEnabled(String action) {

    IView view = getActiveView();

    if( view == null ) {

      return false;

    if ("start-editing".equals(action)) {

      List<FLyrVect> activeLayers = getActiveLayers(view, (FLyrVect layer) -> canBeEdited(layer));

      return !activeLayers.isEmpty();

    } else if ("end-editing".equals(action)) {

      List<FLyrVect> activeLayers = getActiveLayers(view, (FLyrVect layer) -> layer.isEditing());

      return !activeLayers.isEmpty();

    return false;

  }

  @Override

  public boolean canQueryByAction() {

    return true;

  }

  private IView getActiveView() {

    ApplicationManager application = ApplicationLocator.getManager();

    IView view = (IView) application.getActiveComponent(ViewDocument.class);

    return view;

  }

  private boolean isWritable(FLyrVect layer) {

    if (layer != null && layer.isAvailable()) {

      return layer.getFeatureStore().allowWrite();

    }

    return false;

  }

  private boolean canBeEdited(FLyrVect layer) {

    if (layer != null && layer.isAvailable()) {

      boolean isNotTransformed

              = layer.getFeatureStore().getTransforms().isEmpty();

      return isNotTransformed && !layer.isEditing();

    return false;

  }

//  private FLyrVect getActiveLayer(IView vista) {

//    if (vista != null) {

//      ViewDocument viewDocument = vista.getViewDocument();

//      FLayer[] actives

//              = viewDocument.getMapContext().getLayers().getActives();

//

//      if ((actives.length == 1) && (actives[0] instanceof FLyrVect)) {

//        return (FLyrVect) actives[0];

//      }

//    }

//    return null;

//  }

  private List<FLyrVect> getActiveLayers(IView view, Predicate<FLyrVect> valid) {

    if (view == null) {

      return Collections.EMPTY_LIST;

    List<FLyrVect> layers = new ArrayList<>();

    ViewDocument viewDocument = view.getViewDocument();

    FLayer[] actives = viewDocument.getMapContext().getLayers().getActives();

    for (FLayer layer : actives) {

      if (layer instanceof FLyrVect && valid.test((FLyrVect) layer)) {

        layers.add((FLyrVect) layer);

      }

    }

    return layers;

  }

  @Override

  public void update(Observable observable, Object notification) {

    if (notification instanceof Notification) {

      ApplicationManager appManager = ApplicationLocator.getManager();

      Notification n = (Notification) notification;

      if (n.isOfType(EditingContext.CHANGE_SELECTED_TOOL_NOTIFICATION)) {

        String name = (String) n.getValue();

        LOGGER.trace("Changed selected tool to '{}'", name);

        PluginServices.getMainFrame().setSelectedTool(name);

        appManager.refreshMenusAndToolBars();

      } else if (n.isOfType(EditingContext.EXPORT_LAYER_NOTIFICATION)) {

        exportLayer((FLyrVect) (n.getValue()));

      } else if (n.isOfType(EditingContext.REFRESH_TOOLS_NOTIFICATION)) {

        appManager.refreshMenusAndToolBars();

      }

  }

  private void exportLayer(FLyrVect layer) {

    ApplicationManager appManager = ApplicationLocator.getManager();

    I18nManager i18nManager = ToolsLocator.getI18nManager();

    ActionInfo action = PluginsLocator.getActionInfoManager().getAction("layer-exportto");

    action.execute(new Object[]{layer, MODE.toInteger(MODE.DIALOG)});

    String msg = "_Do_you_want_to_finish_editing_If_not_exported_the_data_the_changes_will_be_lost";

    if (appManager.confirmDialog(

            i18nManager.getTranslation(msg),

            i18nManager.getTranslation("end_editing"),

            JOptionPane.YES_NO_OPTION,

            JOptionPane.QUESTION_MESSAGE) == JOptionPane.YES_OPTION) {

      try {

        layer.getFeatureStore().cancelEditing();

      } catch (Exception e) {

        LOGGER.warn("Can't abort editing of layer '" + layer.getName() + "'.", e);

        msg = "_Cant_finish_editing_See_the_error_log_for_more_information";

        appManager.messageDialog(msg, "_Warning", JOptionPane.WARNING_MESSAGE);

      }

    }

  }

  private List<FLyrVect> getEditedLayers() {

    ApplicationManager application = ApplicationLocator.getManager();

    List<FLyrVect> editedLayers = new ArrayList<>();

    Project project = application.getCurrentProject();

    for (Document document : project.getDocuments(ViewManager.TYPENAME)) {

      ViewDocument view = (ViewDocument) document;

      MapContext mapContext = view.getMapContext();

      if (mapContext != null) {

        FLayers layers = mapContext.getLayers();

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

          FLayer lyr = layers.getLayer(j);

          if (lyr instanceof FLyrVect) {

            FLyrVect layerVect = (FLyrVect) lyr;

            if (layerVect.isEditing()) {

              editedLayers.add(layerVect);

          }

      }

    return editedLayers;

  }

  private List<IUnsavedData> getUnsavedData(List<FLyrVect> editedLayers) {

    List<IUnsavedData> unsavedData = new ArrayList<>();

    for (FLyrVect editedLayer : editedLayers) {

      IUnsavedData unsavedDataLayer = new UnsavedLayer(this, editedLayer);

      unsavedData.add(unsavedDataLayer);

    }

    return unsavedData;

  }

  private static class UnsavedLayer extends UnsavedData {

    private final FLyrVect layer;

    public UnsavedLayer(IExtension extension, FLyrVect layer) {

      super(extension);

      this.layer = layer;

    @Override

    public String getDescription() {

      return layer.getName();

    @Override

    public String getResourceName() {

      return layer.getFeatureStore().getFullName();

    @Override

    public boolean saveData() {

      FeatureStore featureStore = layer.getFeatureStore();

      if (featureStore.isEditing()) {

        try {

          featureStore.finishEditing();

          return true;

        } catch (DataException e) {

          throw new RuntimeException(e);

      }

      return true;

  }

  @Override

  public IExtensionStatus getStatus() {

    List<FLyrVect> editedLayers = getEditedLayers();

    final List<IUnsavedData> unsavedData = getUnsavedData(editedLayers);

    return new IExtensionStatus() {

      @Override

      public boolean hasUnsavedData() {

        if (unsavedData == null) {

          return false;

        return !unsavedData.isEmpty();

      }

      @Override

      public boolean hasRunningProcesses() {

        return false;

      }

      @Override

      public IUnsavedData[] getUnsavedData() {

        if (unsavedData == null) {

          return null;

        return unsavedData.toArray(new IUnsavedData[0]);

      }

      @Override

      public IMonitorableTask[] getRunningProcesses() {

        return null;

      }

    };

  }