Application: gvSIG desktop » gvSIG tools: Vector editing

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright ? 2007-2014 gvSIG Association

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 2

 * of the License, or (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

 * MA  02110-1301, USA.

 *

 * For any additional information, do not hesitate to contact us

 * at info AT gvsig.com, or visit our website www.gvsig.com.

 */

package org.gvsig.vectorediting.app.mainplugin;

import java.awt.Component;

import java.awt.event.ActionEvent;

import java.io.File;

import java.util.ArrayList;

import java.util.Collections;

import java.util.HashSet;

import java.util.List;

import java.util.Set;

import java.util.function.Predicate;

import javax.swing.AbstractAction;

import javax.swing.Action;

import javax.swing.JMenuItem;

import javax.swing.JOptionPane;

import javax.swing.JPopupMenu;

import org.apache.commons.collections4.CollectionUtils;

import org.apache.commons.io.FileUtils;

import org.apache.commons.lang.StringUtils;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.gvsig.andami.IconThemeHelper;

import org.gvsig.andami.PluginServices;

import org.gvsig.andami.PluginsLocator;

import org.gvsig.andami.actioninfo.ActionInfo;

import org.gvsig.andami.plugins.Extension;

import org.gvsig.andami.plugins.IExtension;

import org.gvsig.andami.plugins.status.IExtensionStatus;

import org.gvsig.andami.plugins.status.IUnsavedData;

import org.gvsig.andami.plugins.status.UnsavedData;

import org.gvsig.app.ApplicationLocator;

import org.gvsig.app.ApplicationManager;

import org.gvsig.app.extension.evalexpression.EvaluateExpressionExtension;

import org.gvsig.app.extension.evalexpression.EvaluateExpressionPanel;

import org.gvsig.app.extension.evalexpression.notifierfactory.AbstractUpdaterFactory;

import org.gvsig.app.extension.evalexpression.notifierfactory.UpdaterFactory;

import org.gvsig.app.project.Project;

import org.gvsig.app.project.documents.Document;

import org.gvsig.app.project.documents.view.ViewDocument;

import org.gvsig.app.project.documents.view.ViewManager;

import org.gvsig.app.project.documents.view.gui.DefaultViewPanel;

import org.gvsig.app.project.documents.view.gui.IView;

import org.gvsig.app.project.documents.view.toc.actions.EndEditingTocMenuEntry;

import org.gvsig.app.project.documents.view.toc.actions.StartEditingTocMenuEntry;

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

import org.gvsig.expressionevaluator.swing.ExpressionEvaluatorSwingLocator;

import org.gvsig.expressionevaluator.swing.JExpressionBuilder;

import org.gvsig.fmap.dal.exception.DataException;

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

import org.gvsig.fmap.mapcontext.MapContext;

import org.gvsig.fmap.mapcontext.MapContextLocator;

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

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

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

import org.gvsig.fmap.mapcontext.rendering.symbols.ISymbol;

import org.gvsig.fmap.mapcontext.rendering.symbols.SymbolException;

import org.gvsig.fmap.mapcontext.rendering.symbols.SymbolManager;

import org.gvsig.fmap.mapcontrol.MapControl;

import org.gvsig.fmap.mapcontrol.MapControlCreationListener;

import org.gvsig.fmap.mapcontrol.MapControlLocator;

import org.gvsig.fmap.mapcontrol.MapControlManager;

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

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

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynform.spi.DynFormSPILocator;

import org.gvsig.tools.dynform.spi.DynFormSPIManager;

import org.gvsig.tools.extensionpoint.ExtensionPoint;

import org.gvsig.tools.i18n.I18nManager;

import org.gvsig.tools.observer.Notification;

import org.gvsig.tools.observer.Observable;

import org.gvsig.tools.observer.Observer;

import org.gvsig.tools.swing.api.ToolsSwingLocator;

import org.gvsig.tools.swing.api.windowmanager.Dialog;

import org.gvsig.tools.swing.api.windowmanager.WindowManager;

import org.gvsig.tools.swing.api.windowmanager.WindowManager.MODE;

import org.gvsig.tools.swing.api.windowmanager.WindowManager_v2;

import org.gvsig.utils.swing.threads.IMonitorableTask;

import org.gvsig.vectorediting.app.mainplugin.dynformfield.point.JDynFormFieldPointFactory;

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

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

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

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

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

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

import org.gvsig.vectorediting.swing.api.console.EditingConsole;

@SuppressWarnings("UseSpecificCatch")

public class EditingExtension extends Extension implements Observer {

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

    private VectorEditingUpdaterFactory vectorEditingUpdaterFactory;

    @Override

    public void execute(String actionCommand) {

        IView view = getActiveView();

        EditingSwingManager swingManager = EditingSwingLocator.getSwingManager();

        if (view != null) {

            EditingContext editingContext = swingManager.getEditingContext(view.getMapControl());

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

                doStartEditing(view, editingContext);

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

                doEndEditing(view, editingContext);

            } else if ("vector-editing-tooloptions".equalsIgnoreCase(actionCommand)) {

                doToolOptions(editingContext);

            } else if ("vector-editing-ortomode-enable".equalsIgnoreCase(actionCommand)) {

                editingContext.setDrawMode(EditingContext.DRAWMODE_ORTO);

            } else if ("vector-editing-ortomode-disable".equalsIgnoreCase(actionCommand)) {

                editingContext.setDrawMode(EditingContext.DRAWMODE_NORMAL);

            }

        }

    }

    private void doStartEditing(IView view, EditingContext editingContext) {

        ApplicationManager application = ApplicationLocator.getManager();

        MapControl mapControl = view.getMapControl();

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

        }

        EditingConsole console = editingContext.getConsolePanel();

        JPopupMenu popup = console.getComponentPopupMenu();

        boolean needadd = true;

        for (int i = 0; i < popup.getComponentCount(); i++) {

            Component comp = popup.getComponent(i);

            if( StringUtils.equals("ExpressionBuilder",comp.getName()) ) {

                needadd = false;

                break;

            }

        }

        if( needadd ) {

            JMenuItem entry = new JMenuItem(new ExpressionBuilderAction(editingContext, console));

            entry.setName("ExpressionBuilder");

            popup.add(entry);

        }

        ApplicationLocator.getManager().refreshMenusAndToolBars();

    }

    private void doEndEditing(IView view, EditingContext editingContext) {

        List<FLyrVect> activeLayers = getActiveLayers(

                view,

                (FLyrVect layer) -> layer.isEditing()

        );

//                for (FLyrVect layer : activeLayers) {

//                    editingContext.endEdition(layer);

//                }

        if (CollectionUtils.isEmpty(activeLayers)) {

            return;

        }

        if (activeLayers.size() == 1) {

            editingContext.endEdition(activeLayers.get(0));

            ApplicationLocator.getManager().refreshMenusAndToolBars();

        } else {

            showMultilaterFinishEditingPanel(view.getMapControl().getMapContext());

        }

    }

    private void doToolOptions(EditingContext editingContext) {

        I18nManager i18n = ToolsLocator.getI18nManager();

//        EditingSwingManager editingSwingManager = EditingSwingLocator.getSwingManager();

        if (editingContext == null) {

            return;

        }

        WindowManager_v2 windowManager = (WindowManager_v2) ToolsSwingLocator.getWindowManager();

        EditingToolOptionsPanel panel = new EditingToolOptionsPanel(editingContext);

        windowManager.showWindow(

                panel,

                i18n.getTranslation("_Vector_editing_tool_options"),

                WindowManager.MODE.TOOL

        );

    }

    @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(

                StartEditingTocMenuEntry.EXTENSION_POINT_NAME,

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

                new StartEditingTocMenuEntry());

        exPoint.append(

                EndEditingTocMenuEntry.EXTENSION_POINT_NAME,

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

                new EndEditingTocMenuEntry());

        EditingToolOptionsPanel.registerPersistence();

        this.vectorEditingUpdaterFactory = new VectorEditingUpdaterFactory();

        EvaluateExpressionPanel.registerUpdater(this.vectorEditingUpdaterFactory);

    }

    private void registerIcons() {

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

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

//        IconThemeHelper.registerIcon("vectorediting-tools", "vector-editing-tooloptions-confirm", this);

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

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

    }

    @Override

    @SuppressWarnings("Convert2Lambda")

    public void postInitialize() {

        super.postInitialize();

        registerSymbols();

        MapControlManager mapControlManager = MapControlLocator.getMapControlManager();

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

            }

        });

        DynFormSPIManager dynFormManager = DynFormSPILocator.getDynFormSPIManager();

        dynFormManager.registerDynFieldFactory(new JDynFormFieldPointFactory());

    }

    /**

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

        }

        EditingSwingManager swingManager = EditingSwingLocator.getSwingManager();

        EditingContext editingContext = swingManager.getEditingContext(view.getMapControl());

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

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

            return !activeLayers.isEmpty();

        } else if ("vector-editing-ortomode-enable".equals(action)) {

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

            return editingContext.getDrawMode()==EditingContext.DRAWMODE_NORMAL && !activeLayers.isEmpty();

        } else if ("vector-editing-ortomode-disable".equals(action)) {

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

            return editingContext.getDrawMode()==EditingContext.DRAWMODE_ORTO && !activeLayers.isEmpty();

        } else {

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

            return !activeLayers.isEmpty();

        }

    }

    @Override

    @SuppressWarnings("ConvertToStringSwitch")

    public boolean isEnabled(String action) {

        IView view = getActiveView();

        if (view == null) {

            return false;

        }

        EditingSwingManager swingManager = EditingSwingLocator.getSwingManager();

        EditingContext editingContext = swingManager.getEditingContext(view.getMapControl());

        if( editingContext.isProcessing() ) {

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

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

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

            return !activeLayers.isEmpty();

        } else if ("vector-editing-ortomode-enable".equals(action)) {

            return editingContext.getDrawMode()==EditingContext.DRAWMODE_NORMAL;

        } else if ("vector-editing-ortomode-disable".equals(action)) {

            return editingContext.getDrawMode()==EditingContext.DRAWMODE_ORTO;

        }

        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() && layer.isVisible()) {

            return layer.getFeatureStore().allowWrite();

        }

        return false;

    }

    private boolean canBeEdited(FLyrVect layer) {

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

            FeatureStore store = layer.getFeatureStore();

            boolean storeCanBeEdited=  false;

            if(store != null){

                storeCanBeEdited = store.canBeEdited();

            }

            return storeCanBeEdited && !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();

                if( name!=null ) {

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

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

                EditingService activeService = ((EditingContext)observable).getActiveService();

                if(activeService != null){

                    appManager.getMainFrame().setSelectedTool(activeService.getName());

                }

                appManager.refreshMenusAndToolBars();

            }

            this.vectorEditingUpdaterFactory.updateAll(n);

        }

    }

    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;

            }

        };

    }

    private void showMultilaterFinishEditingPanel(MapContext mapContext) {

        I18nManager i18n = ToolsLocator.getI18nManager();

        WindowManager_v2 windowManager = (WindowManager_v2) ToolsSwingLocator.getWindowManager();

        MultilayerFinishEditingPanel finishEditingPanel = new MultilayerFinishEditingPanel(mapContext);

        Dialog dialog = windowManager.createDialog(

                finishEditingPanel.asJComponent(),

                i18n.getTranslation("end_editing"),

                i18n.getTranslation("_List_of_layers_to_finish_editing"),

                WindowManager_v2.BUTTONS_OK_CANCEL

        );

        finishEditingPanel.setDialog(dialog);

        dialog.addActionListener((ActionEvent e) -> {

            if (dialog.getAction() == WindowManager_v2.BUTTON_OK) {

                finishEditingPanel.apply();

            }

        });

        dialog.show(WindowManager.MODE.WINDOW);

    }

    private static class ExpressionBuilderAction extends AbstractAction {

        private final EditingConsole console;

        private final EditingContext editingContext;

        @SuppressWarnings("OverridableMethodCallInConstructor")

        public ExpressionBuilderAction(EditingContext editingContext, EditingConsole console) {

            this.editingContext = editingContext;

            this.console = console;

            I18nManager i18n = ToolsLocator.getI18nManager();

            this.putValue(

                    Action.ACTION_COMMAND_KEY, 

                    "CreateJExpressionBuilderAction"

            );

            this.putValue(

                    Action.NAME, 

                    i18n.getTranslation("_Show_expression_builder")

            );

            this.putValue(

                    Action.SMALL_ICON, 

                    ToolsSwingLocator.getIconThemeManager().getCurrent().get("picker-expression")

            );

        }

        @Override

        public void actionPerformed(ActionEvent e) {

            I18nManager i18n = ToolsLocator.getI18nManager();

            WindowManager_v2 winmgr = (WindowManager_v2) ToolsSwingLocator.getWindowManager();

            final JExpressionBuilder panel = ExpressionEvaluatorSwingLocator.getManager().createJExpressionBuilder();

            panel.getConfig().addSymbolTable(this.editingContext.getContextSymbolTable());

            panel.getConfig().setPreviewSymbolTable(this.editingContext.getContextSymbolTable());

            final Dialog dialog = winmgr.createDialog(

                    panel.asJComponent(),

                    i18n.getTranslation("_Expression_builder"),

                    null, 

                    WindowManager_v2.BUTTONS_OK_CANCEL

            );

            dialog.addActionListener((ActionEvent e2) -> {

                if( dialog.getAction()==WindowManager_v2.BUTTON_OK ) {

                    console.addResponseText(panel.getExpression().getPhrase());

                }

            });

            dialog.show(WindowManager.MODE.DIALOG);

        }

    }

    private static class VectorEditingUpdaterFactory extends AbstractUpdaterFactory {

        private final Set<VectorEditingUpdater> vectorEditingUpdaters = new HashSet<>();

        private class VectorEditingUpdater extends AbstractUpdaterFactory.AbstractUpdater {

            @SuppressWarnings("Convert2Lambda")

            public VectorEditingUpdater(UpdaterFactory factory, Observer observer) {

                super(factory, observer);

            }

            @Override

            public void add() {

                vectorEditingUpdaters.add(this);

            }

            @Override

            public void remove() {

                vectorEditingUpdaters.remove(this);

            }

        }

        public VectorEditingUpdaterFactory() {

            super("VectorEditing", "Actualizar cuando cambie la edicion vectorial");

        }

        @Override

        public UpdaterFactory.Updater create(Observer observer) {

            UpdaterFactory.Updater updater = new VectorEditingUpdater(this, observer);

            return updater;

        }

        public void updateAll(Notification n) {

            for (VectorEditingUpdater vectorEditingUpdater : vectorEditingUpdaters) {

                vectorEditingUpdater.update(n);

            }        

        }

    }

}