Application: gvSIG desktop » gvSIG tools: Vector editing

org.gvsig.vectorediting.swing.api.EditingSwingLibrary

/**

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

import java.awt.Component;

import java.util.List;

import org.gvsig.fmap.mapcontrol.MapControl;

import org.gvsig.tools.service.Manager;

import org.gvsig.utils.console.ResponseListener;

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

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

import org.gvsig.vectorediting.swing.api.contextmenu.AcceptValueListener;

import org.gvsig.vectorediting.swing.api.contextmenu.EditingContextMenu;

/**

 * @author gvSIG team.

 */

public interface EditingSwingManager extends Manager {

    /**

     * @param mapControl

     * @return

     */

    EditingContext getEditingContext(MapControl mapControl);

    /**

     *

     * @param mapControl

     */

    public void registerEditingContext(MapControl mapControl);

    /**

     *

     * @param layerName

     * @return

     */

    int showPanelExportOrDiscard(MapControl parent, String layerName);

    /**

     *

     * @param layerName

     * @return

     */

    int showPanelSaveOrDiscard(MapControl parent, String layerName);

    /**

     * Gets an instance of current parameter contextual menu. To show it, invoke

     * {@link EditingContextMenu#show(java.awt.Component, int, int)}.

     *

     * @param parent

     *            of contextual menu

     * @param parameter

     *            to build contextual menu according to it types.

     * @return contextual menu of parameter

     */

    EditingContextMenu getContextualMenu(Component parent,

        AcceptValueListener listener, EditingServiceParameter parameter);

    /**

     * Gets and instance of {@link EditingConsole}.

     * The response listener will receive the response typed

     * by user when ENTER key is pressed.

     * 

     * @param listener

     *            Object that will received the response

     * @return An instance of {@link EditingConsole}

     */

    EditingConsole getEditingConsole(ResponseListener listener);

    /**

     * Gets and instance of {@link EditingConsole}.

     * Response listener list will receive the response

     * typed by user when ENTER key is pressed.

     * 

     * @param listener

     *            Object that will received the response

     * @return An instance of {@link EditingConsole}

     */

    EditingConsole getEditingConsole(List<ResponseListener> liteners);

}

/**

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

import java.lang.ref.WeakReference;

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

import org.gvsig.fmap.mapcontrol.MapControl;

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

import org.gvsig.tools.observer.Observable;

public interface EditingContext extends Observable {

    static final int CANCEL = 0;

    static final int DISCARD_CHANGES = 1;

    static final int EXPORT_LAYER = 2;

    static final int SAVE_CHANGES = 3;

    static final String DEFAULT_TOOL = "default_tool";

    static final String CHANGE_SELECTED_TOOL_NOTIFICATION = "EditingContext.changeSelectedTool";

    static final String REFRESH_TOOLS_NOTIFICATION = "EditingContext.refreshTools";

    static final String EXPORT_LAYER_NOTIFICATION = "EditingContext.exportLayer";

    /**

     * Activates service as of name and {@link MapControl}

     *

     * @param name

     *            of service

     * @param mapControl

     *            of

     */

    public void activateService(String name);

    /**

      * @deprecated Use {@link EditingContext#beginEdition(FLyrVect)}

     */

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

    /**

     * Begins edition of a layer

     *

     * @param layer

     *            to begin edition

     */

    public void beginEdition(FLyrVect layer);

    /**

     * Ends edition of a layer 

     *

     * @param layer

     *            to end edition

     */

    public void endEdition(FLyrVect layer);

    /**

     * Gets mapControl object. It is referenced by {@link WeakReference}.

     *

     * @return

     */

    public MapControl getMapControl();

    /**

     *

     * @param name

     * @return

     */

    public boolean isServiceCompatible(String name);

    /**

     * Updates the weak reference at editing context.

     *

     * @param mapControl

     */

    public void setMapControl(MapControl mapControl);

    public Behavior[] getDefaultBehaviors();

    public void setDefaultBehaviors(Behavior[] defaultBehaviors);

}

/**

 * 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.api.contextmenu;

import java.awt.Component;

/**

 * @author llmarques

 *

 */

public interface EditingContextMenu {

    /**

     * @param mapControl

     * @param x

     * @param y

     */

    public void show(Component mapControl, int x, int y);

}

/**

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

 */

/* 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.api.contextmenu;

/**

 * @author llmarques

 *

 */

public interface AcceptValueListener {

    public void acceptValue(Object value);

}

/**

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

import org.gvsig.tools.locator.BaseLocator;

import org.gvsig.tools.locator.Locator;

import org.gvsig.tools.locator.LocatorException;

public class EditingSwingLocator extends BaseLocator {

    private static final String LOCATOR_NAME = "EditingSwingLocator";

    public static final String MANAGER_NAME = "VectorEditingSwing.manager";

    private static final String MANAGER_DESCRIPTION =

        "Editing Swing Manager of gvSIG";

    private static final EditingSwingLocator instance =

        new EditingSwingLocator();

    private EditingSwingLocator() {

    }

    /**

     * Return the singleton instance.

     *

     * @return the singleton instance

     */

    public static EditingSwingLocator getInstance() {

        return instance;

    }

    @Override

    public String getLocatorName() {

        return LOCATOR_NAME;

    }

    /**

     * Return a reference to EditingSwingManager.

     *

     * @return a reference to EditingSwingManager

     * @throws LocatorException

     *             if there is no access to the class or the class

     *             cannot be instantiated

     * @see Locator#get(String)

     */

    public static EditingSwingManager getSwingManager() throws LocatorException {

        return (EditingSwingManager) getInstance().get(MANAGER_NAME);

    }

    /**

     * Registers the Class implementing the EditingSwingLocator interface.

     *

     * @param clazz

     *            implementing the EeditingSwingManager interface

     */

    public static void registerManager(Class clazz) {

        getInstance().register(MANAGER_NAME, MANAGER_DESCRIPTION, clazz);

    }

    public static void registerDefaultManager(Class clazz) {

        getInstance().registerDefault(MANAGER_NAME, MANAGER_DESCRIPTION, clazz);

    }

}

/**

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

import org.gvsig.fmap.dal.DALLibrary;

import org.gvsig.fmap.geom.GeometryLibrary;

import org.gvsig.tools.library.AbstractLibrary;

import org.gvsig.tools.library.LibraryException;

import org.gvsig.tools.locator.ReferenceNotRegisteredException;

public class EditingSwingLibrary extends AbstractLibrary {

    @Override

    public void doRegistration() {

        registerAsAPI(EditingSwingLibrary.class);

        require(DALLibrary.class);

        require(GeometryLibrary.class);

    }

    @Override

    protected void doInitialize() throws LibraryException {

        // TODO Auto-generated method stub

    }

    @Override

    protected void doPostInitialize() throws LibraryException {

        EditingSwingManager manager = EditingSwingLocator.getSwingManager();

        if (manager == null) {

            throw new ReferenceNotRegisteredException(

                EditingSwingLocator.MANAGER_NAME,

                EditingSwingLocator.getInstance());

        }

    }

}

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright ? 2007-2015 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.api.console;

import org.gvsig.utils.console.ResponseListener;

/**

 * 

 * @author llmarques

 *

 */

public interface EditingConsole {

    /**

     * Gets response text typed by user

     * 

     * @return

     */

    public String getResponseText();

    /**

     * Clears console

     */

    public void clear();

    /**

     * Adds text to console

     * 

     * @param text

     */

    public void addText(String text);

    /**

     * Add text that is taken like text typed by user

     * 

     * @param responseText

     */

    public void addResponseText(String responseText);

    /**

     * Adds the listener

     * 

     * @param listener

     */

    public void addResponseListener(ResponseListener listener);

    /**

     * Removes the listener

     * 

     * @param listener

     */

    public void removeResponseListener(ResponseListener listener);

}

<?xml version="1.0" encoding="ISO-8859-1"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">

	<modelVersion>4.0.0</modelVersion>

	<artifactId>org.gvsig.vectorediting.swing.api</artifactId>

	<packaging>jar</packaging>

	<name>org.gvsig.vectorediting.swing.api</name>

	<parent>

		<groupId>org.gvsig</groupId>

		<artifactId>org.gvsig.vectorediting.swing</artifactId>

		<version>1.0.120</version>

	</parent>

	<build>

		<plugins>

			<plugin>

				<groupId>org.apache.maven.plugins</groupId>

				<artifactId>maven-jar-plugin</artifactId>

				<configuration>

				</configuration>

				<executions>

					<!-- Generates a jar file only with the test classes -->

					<execution>

						<goals>

							<goal>test-jar</goal>

						</goals>

					</execution>

				</executions>

			</plugin>

		</plugins>

	</build>

	<dependencies>

		<dependency>

			<groupId>org.gvsig</groupId>

			<artifactId>org.gvsig.vectorediting.lib.api</artifactId>

		</dependency>

	</dependencies>

</project>

<?xml version="1.0" encoding="ISO-8859-1"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">

	<modelVersion>4.0.0</modelVersion>

	<artifactId>org.gvsig.vectorediting.swing</artifactId>

	<packaging>pom</packaging>

	<name>org.gvsig.vectorediting.swing</name>

	<parent>

		<groupId>org.gvsig</groupId>

		<artifactId>org.gvsig.vectorediting</artifactId>

		<version>1.0.120</version>

	</parent>

	<modules>

		<module>org.gvsig.vectorediting.swing.api</module>

		<module>org.gvsig.vectorediting.swing.impl</module>

	</modules>

</project>

org.gvsig.vectorediting.swing.impl.DefaultEditingSwingLibrary

/**

 * 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.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.gvsig.fmap.dal.exception.DataException;

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

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.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.gvsig.fmap.geom.primitive.Point;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.expressionevaluator.ExpressionUtils;

import org.gvsig.expressionevaluator.MutableSymbolTable;

import org.gvsig.fmap.dal.DataTypes;

import org.gvsig.fmap.dal.EditingNotification;

import org.gvsig.fmap.dal.EditingNotificationManager;

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

import org.gvsig.temporarystorage.TemporaryStorageGroup;

import org.gvsig.temporarystorage.TemporaryStorageLocator;

import org.gvsig.temporarystorage.TemporaryStorageManager;

import org.gvsig.tools.dataTypes.Coercion;

import org.gvsig.tools.dataTypes.DataTypesManager;

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

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

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

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

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

        }

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

                }

            }

        }

        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 {

                if(defaultValue instanceof Point){

                    Point point = (Point)defaultValue;

                    StringBuilder builder = new StringBuilder();

                    for(int i=0; i<point.getDimension(); i++){

                        builder.append(point.getCoordinateAt(i));

                        if(i < point.getDimension()-1){

                            builder.append(" , ");

                        }

                    }

                    strDefaultValue = builder.toString();

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

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

        }

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

        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"+

//                    i18n.getTranslation("_The_layer_is_marked_as_temporary_to_avoid_possible_problems_when_trying_to_save_the_project")+"\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.editingCompoundBehavior.setDrawnBehavior(

            EditingCompoundBehavior.SELECTION_INDEX, enableSelection);

    }

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

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

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

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

            getMapControl().setTool("VectorEditing");

        }

        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;

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