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.swing.impl;

import java.awt.BorderLayout;

import java.awt.Component;

import java.lang.ref.WeakReference;

import java.lang.reflect.InvocationTargetException;

import java.util.ArrayList;

import java.util.HashSet;

import java.util.Iterator;

import java.util.List;

import java.util.Set;

import java.util.Stack;

import java.util.logging.Level;

import java.util.prefs.PreferenceChangeEvent;

import java.util.prefs.PreferenceChangeListener;

import java.util.prefs.Preferences;

import javax.swing.JComponent;

import javax.swing.JOptionPane;

import javax.swing.SwingUtilities;

import org.apache.commons.lang3.StringUtils;

import org.apache.commons.text.StringEscapeUtils;

import org.gvsig.expressionevaluator.ExpressionEvaluatorLocator;

import org.gvsig.expressionevaluator.ExpressionEvaluatorManager;

import org.gvsig.expressionevaluator.ExpressionUtils;

import org.gvsig.expressionevaluator.Function;

import org.gvsig.expressionevaluator.SymbolTable;

import org.gvsig.fmap.dal.DataTypes;

import org.gvsig.fmap.dal.EditingNotification;

import org.gvsig.fmap.dal.EditingNotificationManager;

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

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

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

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

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

import org.gvsig.fmap.dal.swing.DALSwingLocator;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryUtils;

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

import org.gvsig.fmap.geom.type.GeometryType;

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

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

import org.gvsig.fmap.mapcontext.rendering.legend.IVectorLegend;

import org.gvsig.fmap.mapcontrol.MapControl;

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

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

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.bookmarksandhistory.Bookmark;

import org.gvsig.tools.dataTypes.Coercion;

import org.gvsig.tools.i18n.I18nManager;

import org.gvsig.tools.locator.LocatorException;

import org.gvsig.tools.observer.BaseNotification;

import org.gvsig.tools.observer.Notification;

import org.gvsig.tools.observer.ObservableHelper;

import org.gvsig.tools.observer.Observer;

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

import org.gvsig.tools.swing.api.threadsafedialogs.ThreadSafeDialogsManager;

import org.gvsig.utils.console.JDockPanel;

import org.gvsig.utils.console.ResponseListener;

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

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

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

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

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

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

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

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

import org.gvsig.vectorediting.swing.impl.console.DefaultEditingConsole;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

public class DefaultEditingContext implements EditingContext {

    private static final Logger LOGGER = LoggerFactory

        .getLogger(EditingManager.class);

    private WeakReference<MapControl> mapControlReference;

    private WeakReference<MapContext> mapContextReference;

    private EditingCompoundBehavior editingCompoundBehavior;

    private Behavior[] lastAdditionalBehaviors;

    private final ObservableHelper observableHelper;

    private EditingConsole console;

    private JDockPanel dockConsole = null;

    private boolean isShowConsole = false;

    private final Stack<EditingService> serviceStack;

    private FLyrVect currentLayer;

    private EditingServiceParameter currentParam;

    private Behavior[] defaultBehaviors;

    private Set<FLyrVect> layersSpatialCacheEnabled = new HashSet<>();

    private final LayerListener layerListener = new LayerListener() {

        @Override

        public void activationChanged(final LayerEvent e) {

            if( !SwingUtilities.isEventDispatchThread() ) {

                SwingUtilities.invokeLater(new Runnable() {

                    @Override

                    public void run() {

                        activationChanged(e);

                    }

                });

                return;

            }

            FLayer layer = e.getSource();

            final MapContext mapContext = layer.getMapContext();

            if (countActiveAndEditingLayers(mapContext) > 1) {

                hideConsole();

                return;

            }

            if (layer instanceof FLyrVect) {

                if (layer.isActive()) {

                    if(layer.isEditing()) {

                        getMapControl().setTool("VectorEditing");

                        setCurrentLayer((FLyrVect) layer);

                        showConsole();

                        return;

                    } else {

                        final SpatialCache spatialCache = ((FLyrVect) layer).getSpatialCache();

                        if(!spatialCache.isEnabled()){

                            spatialCache.setEnabled(true);

                            //We keep the list of layers whose spatial cache is enabled here.

                            layersSpatialCacheEnabled.add((FLyrVect) layer);

                        }

                    }

                } else {

                    if(!layer.isEditing()) {

                        //We disabled the spatial cache of the layers that we had enabled here.

                        final SpatialCache spatialCache = ((FLyrVect) layer).getSpatialCache();

                        if(spatialCache.isEnabled() && layersSpatialCacheEnabled.contains((FLyrVect) layer)){

                            spatialCache.setEnabled(false);

                            layersSpatialCacheEnabled.remove((FLyrVect) layer);

                        }

                    }

                }

            }

            FLayer[] activeLayers =

                layer.getMapContext().getLayers().getActives();

            for (FLayer activeLayer : activeLayers) {

                if (activeLayer instanceof FLyrVect) {

                    if (activeLayer.isEditing()) {

                        getMapControl().setTool("VectorEditing");

                        setCurrentLayer((FLyrVect) activeLayer);

                        showConsole();

                        return;

                    }

                }

            }

            hideConsole();

            if ((getMapControl().getCurrentTool() != null)

                && getMapControl().getCurrentTool().equals("VectorEditing")) {

                getMapControl().setPrevTool();

            }

        }

        @Override

        public void drawValueChanged(LayerEvent e) {

        }

        @Override

        public void editionChanged(final LayerEvent e) {

            if( !SwingUtilities.isEventDispatchThread() ) {

                SwingUtilities.invokeLater(new Runnable() {

                    @Override

                    public void run() {

                        editionChanged(e);

                    }

                });

                return;

            }

            FLayer layer = e.getSource();

            if (layer instanceof FLyrVect) {

                if (layer.isEditing()) {

                    synchronized (DefaultEditingContext.this) {

                        beginEdition((FLyrVect) layer);

                        showConsole();

                    }

                } else {

                    hideConsole();

                }

            }

        }

        @Override

        public void nameChanged(LayerEvent e) {

        }

        @Override

        public void visibilityChanged(LayerEvent e) {

        }

    };

    private int countActiveAndEditingLayers(MapContext mapcontext){

        int count = 0;

        FLayer[] activeLayers =

                mapcontext.getLayers().getActives();

        for (FLayer activeLayer : activeLayers) {

            if (activeLayer instanceof FLyrVect) {

                if (activeLayer.isEditing()) {

                    count++;

                }

            }

        }

        return count;

    }

    private final PreferenceChangeListener preferenceChangeListener =

        new PreferenceChangeListener() {

            @Override

            public void preferenceChange(PreferenceChangeEvent evt) {

                String key = evt.getKey();

                if (key.equalsIgnoreCase("apply-snappers")) {

                    boolean newValue = Boolean.parseBoolean(evt.getNewValue());

                    getMapControl().setRefentEnabled(newValue);

                }

            }

        };

    public DefaultEditingContext(MapControl mapControl) {

        this.mapControlReference = new WeakReference<>(mapControl);

        this.mapContextReference =

            new WeakReference<>(mapControl.getMapContext());

        this.observableHelper = new ObservableHelper();

        this.serviceStack = new Stack<>();

        addLayerListeners();

        addPreferenceListener();

    }

    private void addPreferenceListener() {

        Preferences prefs = Preferences.userRoot().node("snappers");

        prefs.addPreferenceChangeListener(preferenceChangeListener);

    }

    @Override

    public void activateService(String name) {

        if ((getMapControl() != null)

            && getMapControl().hasTool("VectorEditing")) {

            CompoundBehavior editingCompoundBehavior =

                getEditingCompoundBehavior();

            getMapControl().setTool("VectorEditing");

            editingCompoundBehavior.setDrawnBehavior(

                EditingCompoundBehavior.EDITING_INDEX, true);

            EditingManager manager = EditingLocator.getManager();

            if (currentLayer != null) {

                IVectorLegend legend = null;

                try {

                    legend = (IVectorLegend) currentLayer.getLegend();

                } catch (Exception e) {

                    LOGGER.trace("Can't retrieve legend from layer.");

                    //DO NOTHING

                }

//                EditingService activeService = getActiveService();

//                if(activeService != null && !activeService.next().getTypes().contains(TYPE.GEOMETRY)) {

//                    activeService.setShowPreviewSymbol(true);

//                }

                EditingService service =

                    manager.getEditingService(name,

                        currentLayer.getFeatureStore(),

                        mapContextReference.get(), 

                        legend);

                if (service != null) {

//                     if(!serviceStack.isEmpty()) { service.setShowPreviewSymbol(false); }

                    this.enableSelection(false);

                    try {

                        service.activate();

                        service.start();                       

                    } catch (StartServiceException e) {

                        LOGGER.info(String.format(

                            "Can't start the service %1$s", service.getName()),

                            e);

                        cleanEditingContext();

                        return;

                    } catch (InvalidEntryException e) {

                        I18nManager i18nManager = ToolsLocator.getI18nManager();

                        showConsoleMessage("\n"

                            + i18nManager.getTranslation("invalid_option"));

                    }

                    if (!serviceStack.isEmpty()){

                        if(getActiveService().next().getTypes().contains(TYPE.GEOMETRY)) {

                            service.setShowPreviewSymbol(false);

                        } else {

//                            service.setShowPreviewSymbol(true);

//                            getActiveService().setShowPreviewSymbol(true);

                            serviceStack.pop();

                        }

                    }

                    setActiveService(service);

                    nextParameter();

                }

            }

        }

    }

    private void addBehaviors(Behavior[] additionalBehavior)

        throws CreateEditingBehaviorException {

        DefaultEditingBehavior editingBehavior;

        EditingCompoundBehavior editingCompoundBehavior;

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

                System.arraycopy(additionalBehavior, 0, behaviors, 1, additionalBehavior.length);

                getMapControl().addBehavior("VectorEditing", behaviors);

                lastAdditionalBehaviors = additionalBehavior;

            } else {

                getMapControl().addBehavior("VectorEditing",

                    editingCompoundBehavior);

            }

        } else {

            editingCompoundBehavior = getEditingCompoundBehavior();

            editingBehavior =

                (DefaultEditingBehavior) editingCompoundBehavior

                    .getBehavior(EditingCompoundBehavior.EDITING_INDEX);

            setCompoundBehavior(editingCompoundBehavior);

            cleanEditingContext();

        }

    }

    private void addLayerListeners() {

        FLayers layers = mapContextReference.get().getLayers();

        layers.addLayerListener(layerListener);

        layers.addLayerCollectionListener(new LayerCollectionListener() {

            public void addLayer(FLayer layer) {

                if (layer instanceof FLayers) {

                    FLayers layers = (FLayers) layer;

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

                        addLayer(layers.getLayer(i));

                    }

                } else if (layer instanceof FLyrVect) {

                    ((FLyrVect) layer).addLayerListener(layerListener);

                }

            }

            @Override

            public void layerAdded(LayerCollectionEvent e) {

                addLayer(e.getLayers());

            }

            @Override

            public void layerAdding(LayerCollectionEvent e)

                throws CancelationException {

            }

            @Override

            public void layerMoved(LayerPositionEvent e) {

            }

            @Override

            public void layerMoving(LayerPositionEvent e)

                throws CancelationException {

            }

            public void removeLayer(FLayer layer) {

                if (layer instanceof FLayers) {

                    FLayers layers = (FLayers) layer;

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

                        addLayer(layers.getLayer(i));

                    }

                } else if (layer instanceof FLyrVect) {

                    ((FLyrVect) layer).removeLayerListener(layerListener);

                }

            }

            @Override

            public void layerRemoved(LayerCollectionEvent e) {

                removeLayer(e.getLayers());

            }

            @Override

            public void layerRemoving(LayerCollectionEvent e)

                throws CancelationException {

            }

            @Override

            public void visibilityChanged(LayerCollectionEvent e)

                throws CancelationException {

            }

        });

    }

    @Override

    public void addObserver(Observer o) {

        this.observableHelper.addObserver(o);

    }

    private void askQuestion(EditingServiceParameter param) {

        I18nManager i18nManager = ToolsLocator.getI18nManager();

        String translation = i18nManager.getTranslation(param.getDescription());

        String activeServiceName =

            i18nManager.getTranslation(getActiveService().getName());

        String strDefaultValue = param.getConsoleDefaultValue();

        if(StringUtils.isBlank(strDefaultValue)) {

            showConsoleMessage("\n" + activeServiceName + "# " + translation + " : ");

        } else {

            showConsoleMessage("\n" + activeServiceName + "# " + translation + "<" + strDefaultValue + "> : ");

        }

    }

    @Override

    public synchronized void beginEdition(FLyrVect layer,

        Behavior[] additionalBehaviors) {

        try{

            throw new Exception("Deprecated method");

        } catch (Exception e){

            LOGGER.info("Deprecated method", e);

        }

        beginEdition(layer);

        try {

            addBehaviors(additionalBehaviors);

        } catch (CreateEditingBehaviorException e1) {

            LOGGER.info("Problems adding behaviors to editing context", e1);

            getMapControl().setTool("pan");

        }

    }

    @Override

    public synchronized void beginEdition(FLyrVect layer) {

        EditingNotificationManager editingNotificationManager =

            DALSwingLocator.getEditingNotificationManager();

        EditingNotification notification =

            editingNotificationManager.notifyObservers(this,

                EditingNotification.BEFORE_ENTER_EDITING_STORE, null, layer,layer.getFeatureStore());

        if (notification.isCanceled()) {

            String msg =

                String.format("Edit layer %1$s canceled by somme observer.",

                    layer.getName());

            LOGGER.info(msg, new StartEditingException(msg, null));

            return;

        }

        setCurrentLayer(layer);

        FeatureStore featureStore = layer.getFeatureStore();

        if (!featureStore.isEditing()) {

            try {

                featureStore.edit();

            } catch (Exception e) {

                String msg =

                    String.format("Can't set %1$s in edit mode",

                        featureStore.getName());

                LOGGER.info(msg, new VectorEditingException(e));

                cleanEditingContext();

                return;

            }

        }

        featureStore.addObserver(getMapControl());

        editingNotificationManager.notifyObservers(this,

            EditingNotification.AFTER_ENTER_EDITING_STORE, null, layer, layer.getFeatureStore());

        enableSnapping();

    }

    @SuppressWarnings({ "rawtypes", "unchecked" })

    private void enableSnapping() {

        Preferences prefs = Preferences.userRoot().node("snappers");

         getMapControl().setRefentEnabled(prefs.getBoolean("apply-snappers", false));

         if (currentLayer != null) {

            ArrayList layersToSnap =

                getMapControl().getMapContext().getLayersToSnap();

            if (!layersToSnap.contains(currentLayer)) {

                layersToSnap.add(currentLayer);

            }

        }

    }

    @SuppressWarnings("rawtypes")

    private void disableSnapping() {

        ArrayList layersToSnap =

            getMapControl().getMapContext().getLayersToSnap();

        if (layersToSnap.contains(currentLayer)) {

            layersToSnap.remove(currentLayer);

        }

    }

    private void changeSelectedTool(String name) {

        if (name.equalsIgnoreCase(DEFAULT_TOOL)) {

            name = "selection-simple-select-view";

            this.getMapControl().setTool("pointSelection");

//            notifyChangeSelectedTool();

        }

    }

    private void notifyChangeSelectedTool() {

        Notification notification = new BaseNotification(

            EditingContext.CHANGE_SELECTED_TOOL_NOTIFICATION,

            null

        );

        this.observableHelper.notifyObservers(this, notification);

    }

    private void cleanEditingContext() {

        serviceStack.clear();

        currentParam = null;

        this.enableSelection(false);

        refreshMenusAndToolBars();

        I18nManager i18nManager = ToolsLocator.getI18nManager();

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

            + "\n");

        notifyChangeSelectedTool();

    }

    @Override

    public void deleteObserver(Observer o) {

        this.observableHelper.deleteObserver(o);

    }

    @Override

    public void deleteObservers() {

        this.observableHelper.deleteObservers();

    }

    private void discardChanges(FLyrVect layer) throws EndEditingException {

        FeatureStore featureStore = layer.getFeatureStore();

        try {

            featureStore.cancelEditing();

        } catch (Exception e) {

            throw new EndEditingException(e);

        }

    }

    private void doAction(FLyrVect layer, int option) {

        ThreadSafeDialogsManager dialogs = ToolsSwingLocator.getThreadSafeDialogsManager();

        I18nManager i18n = ToolsLocator.getI18nManager();

        switch (option) {

        case SAVE_CHANGES:

            try {

                saveChanges(layer);

            } catch (VectorEditingException e) {

                String msg =

                    String.format("Changes can not be saved in %1$s",

                        layer.getName());

                LOGGER.info(msg, e);

                dialogs.messageDialog(                   

                    i18n.getTranslation("_There_are_problems_saving_changes")+"\n\n"+

                    i18n.getTranslation("_See_error_log_for_more_information"), 

                    null, 

                    i18n.getTranslation("_Warning"), 

                    JOptionPane.WARNING_MESSAGE, 

                    "Vectorediting_cant_save_changes"

                );

                return;

            }

            break;

        case DISCARD_CHANGES:

            try {

                discardChanges(layer);

            } catch (VectorEditingException e) {

                String msg =

                    String.format("Changes can not be discared in %1$s",

                        layer.getName());

                LOGGER.info(msg, e);

                dialogs.messageDialog(                   

                    i18n.getTranslation("_There_are_problems_discarding_changes")+"\n"+

                    "\n" + i18n.getTranslation("_See_error_log_for_more_information"), 

                    null, 

                    i18n.getTranslation("_Warning"), 

                    JOptionPane.WARNING_MESSAGE, 

                    "Vectorediting_cant_discard_changes"

                );

                return;

            }

            break;

        case EXPORT_LAYER:

            try {

                exportLayer(layer);

            } catch (VectorEditingException e) {

                String msg =

                    String.format("Changes of %1$s can not be exported",

                        layer.getName());

                LOGGER.info(msg, e);

                dialogs.messageDialog(                   

                    i18n.getTranslation("_There_are_problems_exporting_changes")+"\n\n"+

                    i18n.getTranslation("_See_error_log_for_more_information"), 

                    null, 

                    i18n.getTranslation("_Warning"), 

                    JOptionPane.WARNING_MESSAGE, 

                    "Vectorediting_cant_export_changes"

                );

                return;

            }

            break;

        case CANCEL:

            return;

        }

        cleanEditingContext();

        hideConsole();

        disableSnapping();

        changeSelectedTool(DEFAULT_TOOL);

        FeatureStore featureStore = layer.getFeatureStore();

        featureStore.deleteObserver(getMapControl());

    }

    private void enableSelection(boolean enableSelection) {

        this.getEditingCompoundBehavior().setDrawnBehavior(

                EditingCompoundBehavior.SELECTION_INDEX, enableSelection);

    }

    @Override

    public void endEdition(FLyrVect layer) {

        if (layer.isEditing()) {

            EditingNotificationManager editingNotificationManager =

                DALSwingLocator.getEditingNotificationManager();

            EditingNotification notification =

                editingNotificationManager.notifyObservers(this,

                    EditingNotification.BEFORE_EXIT_EDITING_STORE, null, layer, layer.getFeatureStore());

            if (notification.isCanceled()) {

                String msg =

                    String.format(

                        "Stop edit layer %1$s canceled by somme observer.",

                        layer.getName());

                LOGGER.info(msg, new EndEditingException(msg, null));

            }

            getMapControl().getCanceldraw().setCanceled(true);

            int option;

            EditingSwingManager swingManager =

                EditingSwingLocator.getSwingManager();

            if (layer.isWritable() && getMapControl().getProjection().equals(layer.getProjection()) ) {

                option =

                    swingManager.showPanelSaveOrDiscard(getMapControl(),

                        layer.getName());

            } else {

                option =

                    swingManager.showPanelExportOrDiscard(getMapControl(),

                        layer.getName());

            }

            doAction(layer, option);

            editingNotificationManager.notifyObservers(this,

                EditingNotification.AFTER_EXIT_EDITING_STORE, null, layer, layer.getFeatureStore());

        }

    }

    private void exportLayer(FLyrVect layer) throws EndEditingException {

        Notification notification = new BaseNotification(EditingContext.EXPORT_LAYER_NOTIFICATION,1);

        notification.setValue(layer);

        this.observableHelper.notifyObservers(this, notification);

    }

    protected void finishService() {

        EditingService lastService = serviceStack.pop();

        try {

            if (!serviceStack.isEmpty()

                && getActiveService().next().getTypes().contains(TYPE.GEOMETRY)) {

                Geometry geometry = lastService.finish();

                lastService.setShowPreviewSymbol(true);

                if (geometry != null) {

                    getActiveService().setValue(geometry);

                }

            } else {

                lastService.finishAndStore();

                getMapControl().rePaintDirtyLayers();

                refreshMenusAndToolBars();

                I18nManager i18nManager = ToolsLocator.getI18nManager();

                showConsoleMessage("\n"

                    + i18nManager.getTranslation(lastService.getName()) + "# "

                    + i18nManager.getTranslation("finished") + "\n");

//                lastService.stop();

                setActiveService(lastService);

//                lastService.start();

                lastService.restart();

                changeSelectedTool(getActiveService().getName());

            }

        } catch (InvalidEntryException ex) {

            I18nManager i18nManager = ToolsLocator.getI18nManager();

            showConsoleMessage("\n"

                + i18nManager.getTranslation("invalid_option"));

            changeSelectedTool(getActiveService().getName());

        } catch (VectorEditingException ex) {

            LOGGER.info("Can't finish " + lastService.getName(), ex);

            cleanEditingContext();

            return;

        }

        nextParameter();

    }

    public EditingService getActiveService() {

        if (!serviceStack.isEmpty()) {

            return serviceStack.peek();

        }

        return null;

    }

    public EditingConsole getConsolePanel() {

        if (console == null) {

            console = new DefaultEditingConsole(new ResponseListener() {

                @Override

                public void acceptResponse(String response) {

                    textEntered(response);

                }

            });

        }

        return console;

    }

    protected FLyrVect getCurrentLayer() {

        return this.currentLayer;

    }

    protected EditingServiceParameter getCurrentParam() {

        return this.currentParam;

    }

    private Component getDockConsole() {

        if (dockConsole == null) {

            dockConsole = new JDockPanel((JComponent) getConsolePanel());

        }

        return dockConsole;

    }

    private DefaultEditingBehavior getEditingBehavior() {

        if (editingCompoundBehavior != null) {

            return (DefaultEditingBehavior) editingCompoundBehavior

                .getBehavior(EditingCompoundBehavior.EDITING_INDEX);

        }

        return null;

    }

    private EditingCompoundBehavior getEditingCompoundBehavior() {

        if (editingCompoundBehavior != null) {

            return editingCompoundBehavior;

        } else {

            EditingCompoundBehavior editingCompoundBehavior;

            CompoundBehavior compoundBehavior =

                (CompoundBehavior) getMapControl().getMapTool("VectorEditing");

            if (compoundBehavior instanceof EditingCompoundBehavior) {

                editingCompoundBehavior =

                    (EditingCompoundBehavior) compoundBehavior;

            } else {

                editingCompoundBehavior =

                    (EditingCompoundBehavior) compoundBehavior.getBehavior(0);

            }

            setCompoundBehavior(editingCompoundBehavior);

            return editingCompoundBehavior;

        }

    }

    @Override

    public MapControl getMapControl() {

        return mapControlReference.get();

    }

    public void nextParameter() {

        if ((getMapControl().getCurrentTool() != null)

            && !getMapControl().getCurrentTool().equals("VectorEditing")) {

            getMapControl().setTool("VectorEditing");

        }

        EditingService activeService = getActiveService();

        currentParam = activeService.next();

        if (currentParam == null) {

            finishService();

        } else {

            askQuestion(currentParam);

            if (currentParam.getTypes().contains(TYPE.SELECTION)) {

                enableSelection(true);

            } else if (currentParam.getTypes().contains(TYPE.GEOMETRY)) {

                refreshMenusAndToolBars();

            }

        }

    }

    protected Stack<EditingService> getServiceStack() {

        return this.serviceStack;

    }

    private void hideConsole() {

        isShowConsole = false;

        if( !SwingUtilities.isEventDispatchThread() ) {

            try {

                SwingUtilities.invokeAndWait(new Runnable() {

                    @Override

                    public void run() {

                        hideConsole();

                    }

                });

                return;

            } catch (InterruptedException | InvocationTargetException ex) {

                LOGGER.warn("Can't hide editing console.",ex);

            }

            return;

        }

        getDockConsole().setVisible(false);

    }

    @Override

    public boolean isServiceCompatible(String name) {

        DefaultEditingBehavior editingBehavior = getEditingBehavior();

        if (editingBehavior != null) {

            try {

                EditingManager manager = EditingLocator.getManager();

                EditingServiceInfo serviceInfo = manager.getServiceInfo(name);

                GeometryType geoType = null;

                for (EditingService editingService : getServiceStack()) {

                    EditingServiceParameter parameter = editingService.next();

                    if (parameter != null) {

                        if (parameter.getTypes().contains(TYPE.GEOMETRY)) {

                            int geometryType = parameter.getGeometryType();

                            int subType = -1;

                            try {

                                subType

                                        = getCurrentLayer().getFeatureStore()

                                                .getDefaultFeatureType()

                                                .getDefaultGeometryAttribute()

                                                .getGeomType().getSubType();

                                geoType

                                        = GeometryLocator.getGeometryManager()

                                                .getGeometryType(geometryType, subType);

                            } catch (Exception e) {

                                String msg

                                        = String.format(

                                                "Problems getting default feature"

                                                + " type of %1$s or getting geometry"

                                                + " type of %2$s %3$s",

                                                getCurrentLayer().getName(), geometryType,

                                                subType);

                                throw new ServiceInformationException(msg, e);

                            }

                            return serviceInfo.isCompatibleWith(geoType)

                                    && serviceInfo.createsNewGeometries();

                        }

                    }

                }

                if (getCurrentLayer() != null) {

                    try {

                        geoType

                                = getCurrentLayer().getFeatureStore()

                                        .getDefaultFeatureType()

                                        .getDefaultGeometryAttribute().getGeomType();

                        if (serviceInfo.isCompatibleWith(geoType)) {

                            return true;

                        }

                    } catch (DataException e) {

                        String msg

                                = String.format("Problems getting default "

                                        + "feature type of %1$s", getCurrentLayer()

                                                .getName());

                        throw new ServiceInformationException(msg, e);

                    }

                }

                return false;

            } catch (ServiceInformationException e) {

                LOGGER.warn(

                    "Problems getting if editing context is compatible with "

                        + name, e);

            }

        }

        return false;

    }

    private static final EditingContextSymbolTable contextSymbolTable = new EditingContextSymbolTable();

    @Override

    public SymbolTable getContextSymbolTable() {

        return contextSymbolTable;

    }

    @Override

    public Point parsePoint(String response) throws ParsePointException {

        response = fixResponseUsingBookmarks(response);

        try {

            Object x = ExpressionUtils.evaluate(contextSymbolTable, response);

            if( x instanceof Point ) {

                contextSymbolTable.addPoint((Point) x);

                return (Point) x;

            }

        } catch(Exception ex) {

            LOGGER.debug("Can't evaluate: "+StringEscapeUtils.escapeJava(response),ex);

        }

        String s = "ST_MakePoint("+response+")";

        try {

            Object x = ExpressionUtils.evaluate(contextSymbolTable, s);

            if( x instanceof Point ) {

                contextSymbolTable.addPoint((Point) x);

                return (Point) x;

            }

        } catch(Exception ex) {

            throw new ParsePointException(ex);

        }

        throw new ParsePointException(null);

    }

    private Double parseValue(String response) throws ParseValueException {

        response = fixResponseUsingBookmarks(response);

        try {

            Object x = ExpressionUtils.evaluate(contextSymbolTable, response);

            if( x instanceof Double ) {

                return (Double) x;

            }  

            if( x==null ) {

                throw new ParseValueException(new NullPointerException());

            }

            Coercion toDouble = ToolsLocator.getDataTypesManager().get(DataTypes.DOUBLE).getCoercion();

            return (Double) toDouble.coerce(x);

        } catch(Exception ex) {

            throw new ParseValueException(ex);

        }

    }

    protected String fixResponseUsingBookmarks(String response) throws LocatorException {

        if( response != null ) {

            response = response.trim();

            int n = StringUtils.indexOf(response, " ");

            if(n>0){

                String name = StringUtils.left(response, n);

                Function fn = contextSymbolTable.function(name);

                if(fn != null){

                    response = name+"("+response.substring(n)+")";

                }

            }

        }

        return response;

    }

    protected void refreshMenusAndToolBars() {

        if (!SwingUtilities.isEventDispatchThread()) {

            SwingUtilities.invokeLater(new Runnable() {

                @Override

                public void run() {

                    refreshMenusAndToolBars();

                }

            });

            return;

        }

        Notification notification = new BaseNotification(

                EditingContext.REFRESH_TOOLS_NOTIFICATION,

                null

        );

        this.observableHelper.notifyObservers(this, notification);

    }

    private void saveChanges(FLyrVect layer) throws EndEditingException {

        FeatureStore featureStore = layer.getFeatureStore();

        try {

            featureStore.finishEditing();

        } catch (Exception e) {

            throw new EndEditingException(e);

        }

    }

    private void setActiveService(EditingService service) {

        serviceStack.add(service);

        notifyChangeSelectedTool();

    }

    private void setCompoundBehavior(EditingCompoundBehavior compoundBehavior) {

        this.editingCompoundBehavior = compoundBehavior;

    }

    private void setCurrentLayer(FLyrVect layer) {

        if (this.currentLayer != layer) {

            this.currentLayer = layer;

            cleanEditingContext();

        }

    }

    @Override

    public void setMapControl(MapControl mapControl) {

        this.mapControlReference = new WeakReference<>(mapControl);

        this.mapContextReference =

            new WeakReference<>(mapControl.getMapContext());

        // When mapControl is updated we have to add older additional behaviors

        // to new mapControl

        if (lastAdditionalBehaviors != null) {

            try {

                addBehaviors(lastAdditionalBehaviors);

            } catch (CreateEditingBehaviorException e1) {

                LOGGER.info("Problems adding behaviors to editing context", e1);

                getMapControl().setTool("pan");

            }

        }

    }

    private void showConsole() {

        if (isShowConsole) {

            return;

        }

        if( !SwingUtilities.isEventDispatchThread() ) {

            try {

                SwingUtilities.invokeAndWait(new Runnable() {

                    @Override

                    public void run() {

                        showConsole();

                    }

                });

                return;

            } catch (InterruptedException | InvocationTargetException ex) {

                LOGGER.warn("Can't show editing console.",ex);

            }

            return;

        }

        isShowConsole = true;

        getMapControl().remove(getDockConsole());

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

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

        getDockConsole().setVisible(true);

    }

    protected void showConsoleMessage(final String text) {

        if (!SwingUtilities.isEventDispatchThread()) {

            SwingUtilities.invokeLater(new Runnable() {

                @Override

                public void run() {

                    showConsoleMessage(text);

                }

            });

            return;

        }

        getConsolePanel().addText(text);

    }

    @Override

    public void cancelActiveService() {

        this.textEntered(null);

    }

    protected void selectedValue(Object value) {

        EditingService activeService = getActiveService();

        I18nManager i18nManager = ToolsLocator.getI18nManager();

        try {

            activeService.setValue(value);

        } catch (InvalidEntryException ex) {

            showConsoleMessage("\n"

                    + i18nManager.getTranslation("invalid_option"));

        }

        activeService = getActiveService();

        if (activeService != null) {

            nextParameter();

        } else {

            cleanEditingContext();

        }

    }

    protected void textEntered(String response) {

        FeatureStore featureStore = getCurrentLayer().getFeatureStore();

        EditingService activeService = getActiveService();

        if (response == null) {

            if (activeService != null) {

                try {

                    activeService.stop();

                    serviceStack.pop();

                    if (serviceStack.isEmpty()) {

                        featureStore

                            .getFeatureSelection().deselectAll();

                        changeSelectedTool(DEFAULT_TOOL);

                    } else {

                        changeSelectedTool(activeService.getName());

                    }

                    refreshMenusAndToolBars();

                    activeService = getActiveService();

                    if (activeService != null) {

                        nextParameter();

                    } else {

                        cleanEditingContext();

                    }

                } catch (StopServiceException e) {

                    LOGGER

                        .info("Can't stop " + activeService.getName(), e);

                } catch (DataException e) {

                    LOGGER.info("Can't get selection of "

                        + featureStore.getFullName(), e);

                }

            }

        } else {

            I18nManager i18nManager = ToolsLocator.getI18nManager();

            if (getCurrentParam() != null) {

                try {

                    Object coercedValue = coerceInputParameter(getCurrentParam(), response);

                    activeService.setValue(coercedValue);

                } catch (InvalidEntryException ex) {

                    showConsoleMessage("\n"

                            + i18nManager.getTranslation("invalid_option"));

                }

            }

            activeService = getActiveService();

            if (activeService != null) {

                nextParameter();

            } else {

                cleanEditingContext();

            }

        }

    }

    private Object coerceInputParameter(EditingServiceParameter parameter, String input) throws InvalidEntryException {

        if (parameter != null) {

            FeatureStore featureStore = getCurrentLayer().getFeatureStore();

            Set<TYPE> types = parameter.getTypes();

            Point point = null;

            Double value = null;

            Point defaultPoint = null;

            Object defaultValue = parameter.getDefaultValue();

            boolean insertedValue = false;

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

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

                defaultPoint = (Point) defaultValue;

                try {

                    if (StringUtils.isEmpty(input.replace("\n", ""))) {

                        point = defaultPoint;

                    } else {

                        point = parsePoint(input);

                    }

                    if (point != null) {

                        return point;

                    }

                } catch (ParsePointException e) {

                    // Do nothing to try other types

                }

            }

            if (types.contains(TYPE.VALUE)) {

                try {

                    value = parseValue(input);

                    if (value != null) {

                        return value;

                    }

                } catch (ParseValueException e) {

                    // Do nothing to try other types

                }

            }

            if (types.contains(TYPE.OPTION)) {

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

                return input;

            }

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

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

                    enableSelection(false);

                    insertedValue = true;

                    FeatureSelection clonedSelection;

                    try {

                        clonedSelection = (FeatureSelection) featureStore

                                .getFeatureSelection().clone();

                        if (clonedSelection.isEmpty()) {

                            throw new InvalidEntryException(null);

                        }

                    } catch (InvalidEntryException e) {