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.util.ArrayList;

import java.util.Set;

import java.util.Stack;

import java.util.prefs.PreferenceChangeEvent;

import java.util.prefs.PreferenceChangeListener;

import java.util.prefs.Preferences;

import javax.swing.JComponent;

import org.gvsig.editing.EditingNotification;

import org.gvsig.editing.EditingNotificationManager;

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

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

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryManager;

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.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.tools.ToolsLocator;

import org.gvsig.tools.i18n.I18nManager;

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.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 ObservableHelper observableHelper;

    private EditingConsole console;

    private JDockPanel dockConsole = null;

    private boolean isShowConsole = false;

    private Stack<EditingService> serviceStack;

    private FLyrVect currentLayer;

    private EditingServiceParameter currentParam;

    private Behavior[] defaultBehaviors;

    private LayerListener layerListener = new LayerListener() {

        public void activationChanged(LayerEvent e) {

            FLayer layer = e.getSource();

            FLayer[] activeLayers =

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

            if ((activeLayers.length == 1) && (layer instanceof FLyrVect)) {

                if (layer.isActive() && layer.isEditing()) {

                    getMapControl().setTool("VectorEditing");

                    setCurrentLayer((FLyrVect) layer);

                    showConsole();

                    return;

                }

            }

            hideConsole();

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

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

                getMapControl().setPrevTool();

            }

        }

        public void drawValueChanged(LayerEvent e) {

        }

        public void editionChanged(LayerEvent e) {

            FLayer layer = e.getSource();

            if (layer instanceof FLyrVect) {

                if (layer.isEditing()) {

                    synchronized (DefaultEditingContext.this) {

                        beginEdition((FLyrVect) layer);

                        showConsole();

                    }

                } else {

                    hideConsole();

                }

            }

        }

        public void nameChanged(LayerEvent e) {

        }

        public void visibilityChanged(LayerEvent e) {

        }

    };

    private PreferenceChangeListener preferenceChangeListener =

        new PreferenceChangeListener() {

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

        this.mapContextReference =

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

        this.observableHelper = new ObservableHelper();

        this.serviceStack = new Stack<EditingService>();

        addLayerListeners();

        addPreferenceListener();

    }

    private void addPreferenceListener() {

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

        prefs.addPreferenceChangeListener(preferenceChangeListener);

    }

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

                EditingService service =

                    manager.getEditingService(name,

                        currentLayer.getFeatureStore(),

                        mapContextReference.get());

                if (service != null) {

                    this.enableSelection(false);

                    try {

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

                        && !getActiveService().next().getTypes()

                            .contains(TYPE.GEOMETRY)) {

                        serviceStack.pop();

                    }

                    setActiveService(service);

                    getNextParameter();

                }

            }

        }

    }

    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;

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

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

                }

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

                }

            }

            public void layerAdded(LayerCollectionEvent e) {

                addLayer(e.getLayers());

            }

            public void layerAdding(LayerCollectionEvent e)

                throws CancelationException {

            }

            public void layerMoved(LayerPositionEvent e) {

            }

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

                }

            }

            public void layerRemoved(LayerCollectionEvent e) {

                removeLayer(e.getLayers());

            }

            public void layerRemoving(LayerCollectionEvent e)

                throws CancelationException {

            }

            public void visibilityChanged(LayerCollectionEvent e)

                throws CancelationException {

            }

        });

    }

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

        Object defaultValue = param.getDefaultValue();

        String strDefaultValue;

        if (defaultValue != null) {

            if (defaultValue instanceof String) {

                strDefaultValue = (String) defaultValue;

                strDefaultValue =

                    i18nManager.getTranslation((String) defaultValue);

            } else {

                strDefaultValue = defaultValue.toString();

            }

            showConsoleMessage("\n" + activeServiceName + "# " + translation

                + "<" + strDefaultValue + "> : ");

        } else {

            showConsoleMessage("\n" + activeServiceName + "# " + translation

                + " : ");

        }

    }

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

            return;

        }

    }

    public synchronized void beginEdition(FLyrVect layer) {        

        EditingNotificationManager editingNotificationManager =

            MapControlLocator.getEditingNotificationManager();

        EditingNotification notification =

            editingNotificationManager.notifyObservers(this,

                EditingNotification.BEFORE_ENTER_EDITING_STORE, null, layer);

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

        enableSnapping();

    }

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

    private void enableSnapping() {

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

        if ((prefs.getBoolean("apply-snappers", false) && 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");

        }

        Notification notification =

            new BaseNotification(

                EditingContext.CHANGE_SELECTED_TOOL_NOTIFICATION,

                new Object[] { name });

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

    }

    public void deleteObserver(Observer o) {

        this.observableHelper.deleteObserver(o);

    }

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

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

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

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

                return;

            }

            break;

        case CANCEL:

            return;

        }

        cleanEditingContext();

        hideConsole();

        disableSnapping();

        changeSelectedTool(DEFAULT_TOOL);

        FeatureStore featureStore = layer.getFeatureStore();

        featureStore.deleteObserver(getMapControl());

    }

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

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

        }

    }

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

                if (geometry != null) {

                    getActiveService().setValue(geometry);

                }

            } else {

                lastService.finishAndStore();

                getMapControl().rePaintDirtyLayers();

                I18nManager i18nManager = ToolsLocator.getI18nManager();

                showConsoleMessage("\n"

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

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

                lastService.stop();

                setActiveService(lastService);

                lastService.start();

                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;

        }

        getNextParameter();

    }

    protected EditingService getActiveService() {

        if (!serviceStack.isEmpty()) {

            return serviceStack.peek();

        }

        return null;

    }

    private EditingConsole getConsolePanel() {

        if (console == null) {

            console = new DefaultEditingConsole(new ResponseListener() {

                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;

        }

    }

    public MapControl getMapControl() {

        return mapControlReference.get();

    }

    protected void getNextParameter() {

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

        getDockConsole().setVisible(false);

    }

    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

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

                    } catch (DataException e) {

                        String msg =

                            String.format("Problems getting default "

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

                                .getName());

                        throw new ServiceInformationException(msg, e);

                    }

                    return serviceInfo.isCompatibleWith(geoType);

                }

                return false;

            } catch (ServiceInformationException e) {

                logger.warn(

                    "Problems getting if editing context is compatible with "

                        + name, e);

            }

        }

        return false;

    }

    private Point parsePoint(String response) throws ParsePointException {

        String[] numbers = new String[1];

        numbers[0] = response;

        numbers = response.split(",");

        if (numbers.length == 2) {

            if (numbers[0].startsWith("(") && numbers[1].endsWith(")\n")) { // CCS

                numbers[0] = numbers[0].replace("(", "");

                numbers[1] = numbers[1].replace(")\n", "");

            }

            double[] values;

            try {

                values =

                    new double[] { Double.parseDouble(numbers[0]),

                        Double.parseDouble(numbers[1]) };

            } catch (Exception e) {

                throw new ParsePointException(e);

            }

            Point point;

            try {

                GeometryManager geomManager =

                    GeometryLocator.getGeometryManager();

                int subType =

                    getCurrentLayer().getFeatureStore().getDefaultFeatureType()

                        .getDefaultGeometryAttribute().getGeomType()

                        .getSubType();

                point = geomManager.createPoint(values[0], values[1], subType);

            } catch (Exception e) {

                throw new ParsePointException(e);

            }

            return point;

        } else {

            throw new ParsePointException(null);

        }

    }

    private Double parseValue(String response) throws ParseValueException {

        try {

            return Double.valueOf(response);

        } catch (Exception e) {

            throw new ParseValueException(e);

        }

    }

    protected void refreshMenusAndToolBars() {

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

    }

    private void setCompoundBehavior(EditingCompoundBehavior compoundBehavior) {

        this.editingCompoundBehavior = compoundBehavior;

    }

    private void setCurrentLayer(FLyrVect layer) {

        if (this.currentLayer != layer) {

            this.currentLayer = layer;

            cleanEditingContext();

        }

    }

    public void setMapControl(MapControl mapControl) {

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

        this.mapContextReference =

            new WeakReference<MapContext>(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");

                return;

            }

        }

    }

    private void showConsole() {

        if (isShowConsole) {

            return;

        }

        isShowConsole = true;

        getMapControl().remove(getDockConsole());

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

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

        getDockConsole().setVisible(true);

    }

    protected void showConsoleMessage(String text) {

        getConsolePanel().addText(text);

    }

    protected void textEntered(String response) {

        FeatureStore featureStore = getCurrentLayer().getFeatureStore();

        if (response == null) {

            if (getActiveService() != null) {

                try {

                    getActiveService().stop();

                    serviceStack.pop();

                    if (serviceStack.isEmpty()) {

                        featureStore

                            .getFeatureSelection().deselectAll();

                        changeSelectedTool(DEFAULT_TOOL);

                    } else {

                        changeSelectedTool(getActiveService().getName());

                    }

                    refreshMenusAndToolBars();

                    if (getActiveService() != null) {

                        getNextParameter();

                    } else {

                        cleanEditingContext();

                    }

                } catch (StopServiceException e) {

                    logger

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

                    return;

                } catch (DataException e) {

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

                        + featureStore.getFullName(), e);

                    return;

                }

            }

        } else {

            if (getCurrentParam() != null) {

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

                Point point = null;

                Double value = null;

                boolean insertedValue = false;

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

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

                    try {

                        point = parsePoint(response);

                        if (point != null) {

                            getActiveService().setValue(point);

                            insertedValue = true;

                        }

                    } catch (VectorEditingException e) {

                        // Do nothing to try other types

                    }

                }

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

                    try {

                        value = parseValue(response);

                        if (value != null) {

                            getActiveService().setValue(value);

                            insertedValue = true;

                        }

                    } catch (VectorEditingException e) {

                        // Do nothing to try other types

                    }

                }

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

                    try {

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

                        if (response != null) {

                            getActiveService().setValue(response);

                            insertedValue = true;

                        }

                    } catch (VectorEditingException e) {

                        // Do nothing to try other types

                    }

                }

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

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

                        enableSelection(false);

                        insertedValue = true;

                        try {

                            getActiveService().setValue(

                                featureStore

                                    .getFeatureSelection().clone());

                        } catch (InvalidEntryException e) {

                            I18nManager i18nManager =

                                ToolsLocator.getI18nManager();

                            showConsoleMessage("\n"

                                + i18nManager.getTranslation("invalid_option"));

                        } catch (Exception e) {

                            logger.info("Can't access to selection.", e);

                            cleanEditingContext();

                            return;

                        }

                    }

                }

                if (!insertedValue) {

                    I18nManager i18nManager = ToolsLocator.getI18nManager();

                    showConsoleMessage("\n"

                        + i18nManager.getTranslation("invalid_option"));

                }

                getNextParameter();

            }

        }

    }

    public void setDefaultBehaviors(Behavior[] defaultBehaviors) {

        this.defaultBehaviors = defaultBehaviors;

        try {

            addBehaviors(defaultBehaviors);

        } catch (CreateEditingBehaviorException e1) {

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

            getMapControl().setTool("pan");

            return;

        }

    }

    public Behavior[] getDefaultBehaviors() {

        return this.defaultBehaviors;

    }

}