Application: gvSIG desktop

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright (C) 2007-2013 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 3

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

import java.awt.BorderLayout;

import java.awt.Dimension;

import java.awt.ScrollPane;

import java.util.ArrayList;

import java.util.Iterator;

import java.util.List;

import javax.swing.JOptionPane;

import javax.swing.JPanel;

import javax.swing.SwingUtilities;

import org.gvsig.andami.PluginServices;

import org.gvsig.andami.messages.NotificationManager;

import org.gvsig.andami.ui.mdiManager.IWindow;

import org.gvsig.app.ApplicationLocator;

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

import org.gvsig.editing.layers.FactoryLayerEdited;

import org.gvsig.editing.layers.ILayerEdited;

import org.gvsig.editing.layers.VectorialLayerEdited;

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

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

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

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

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

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

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

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

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

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

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.feature.rule.CheckMandatoryAttributesRule;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.Geometry.SUBTYPES;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryManager;

import org.gvsig.fmap.geom.exception.CreateEnvelopeException;

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

import org.gvsig.fmap.mapcontext.exceptions.CancelEditingLayerException;

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

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

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.mapcontrol.MapControl;

import org.gvsig.fmap.mapcontrol.MapControlLocator;

import org.gvsig.fmap.mapcontrol.MapControlManager;

import org.gvsig.gui.beans.buttonspanel.ButtonsPanel;

import org.gvsig.gui.beans.buttonspanel.ButtonsPanelEvent;

import org.gvsig.gui.beans.buttonspanel.ButtonsPanelListener;

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.dynobject.DynObjectSwingManager;

import org.gvsig.tools.swing.api.dynobject.JDynObjectComponent;

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

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

public class EditionManager implements LayerListener, LayerCollectionListener, IEditionManager {

    private static final Logger LOG = LoggerFactory

        .getLogger(EditionManager.class);

    private List<ILayerEdited> editedLayers = new ArrayList<ILayerEdited>();

    private MapControl mapCtrl = null;

    private ILayerEdited ile = null;

    private ObservableHelper observableHelper = new ObservableHelper();

    private GeometryManager geomManager = GeometryLocator.getGeometryManager();

    private MapControlManager mapControlManager = MapControlLocator.getMapControlManager();

    /* (non-Javadoc)

         * @see org.gvsig.editing.IEditionManager#getLayerEdited(org.gvsig.fmap.mapcontext.layers.FLayer)

         */

    public ILayerEdited getLayerEdited(FLayer lyr) {

        ILayerEdited aux = null;

        for (int i = 0; i < editedLayers.size(); i++) {

            aux = editedLayers.get(i);

            if (aux.getLayer() == lyr)

                return aux;

        }

        return null;

    }

    /* (non-Javadoc)

         * @see org.gvsig.editing.IEditionManager#editLayer(org.gvsig.fmap.mapcontext.layers.vectorial.FLyrVect, org.gvsig.app.project.documents.view.gui.DefaultViewPanel)

         */

    public void editLayer(FLyrVect lv, DefaultViewPanel vista)

        throws DataException {

        notifyObservers(EditionNotifycation.BEFORE_ENTER_EDIT_LAYER, lv, null, null);

        CADExtension.initFocus();

        vista.showConsole();

        MapControl mapControl = vista.getMapControl();

        this.setMapControl(mapControl);

        lv.addLayerListener(this);

        // This line also enables the spatial cache for snapping:

        lv.getFeatureStore().edit();

        lv.getFeatureStore().addObserver(vista);

        ApplicationLocator.getManager().refreshMenusAndToolBars();

        lv.getFeatureStore().addObserver(mapControl);

        StartEditing.startCommandsApplicable(vista, lv);

        // vista.repaintMap();

        // ----------------------------

        // this forces a true repaint:

        lv.drawValueChanged(LayerEvent.createDrawValuesChangedEvent(lv, ""));

        notifyObservers(EditionNotifycation.AFTER_ENTER_EDIT_LAYER, lv, null, null);

    }

    public void visibilityChanged(LayerEvent e) {

    }

    public void activationChanged(LayerEvent e) {

        if (e.getSource().isActive()) {

            ile = getLayerEdited(e.getSource());

        }

        if (ile == null || ile.getLayer().equals(e.getSource())) {

            if (ile != null && !ile.getLayer().isActive()) {

                VectorialLayerEdited lastVLE = (VectorialLayerEdited) ile;

                lastVLE.activationLost(e);

            }

            if (e.getSource() instanceof FLyrVect) {

                VectorialLayerEdited vle = null;

                vle = (VectorialLayerEdited) getLayerEdited(e.getSource());

                ile = vle;

                if (getMapControl() != null && vle != null

                    && vle.getLayer().isActive()) {

                    getMapControl().setTool("cadtooladapter");

                    vle.activationGained(e);

                    return;

                }

            }

            if (getMapControl() != null) {

                getMapControl().setTool("zoomIn");

                PluginServices.getMainFrame().setSelectedTool("ZOOM_IN");

            }

        }

    }

    public void nameChanged(LayerEvent e) {

    }

    public void editionChanged(LayerEvent e) {

        ILayerEdited lyrEdit = getLayerEdited(e.getSource());

        // Si no est? en la lista, comprobamos que est? en edici?n

        // y lo a?adimos

        if ((lyrEdit == null) && e.getSource().isEditing()) {

            lyrEdit =

                FactoryLayerEdited.createLayerEdited(e.getSource(), mapCtrl);

            editedLayers.add(lyrEdit);

            if (getMapControl() != null) {

                getMapControl().setTool("cadtooladapter");

                CADExtension.setCADTool("_selection", true);

            }

            PluginServices.getMainFrame().setSelectedTool("_selection");

            // idActiveLayer = editedLayers.size() - 1;

            ile = getLayerEdited(e.getSource());

            LOG.debug("NUEVA CAPA EN EDICION: {}", lyrEdit.getLayer().getName());

            // Ponemos el resto de temas desactivados

            if (mapCtrl != null)

                mapCtrl.getMapContext().getLayers().setActive(false);

            // y activamos el nuevo.

            e.getSource().setActive(true);

            if (e.getSource() instanceof FLyrVect) {

                FLyrVect fLyrVect = (FLyrVect) e.getSource();

                ((VectorialLayerEdited) lyrEdit)

                    .setEditionChangeManager(new EditionChangeManager(fLyrVect));

                addCheckRules(fLyrVect);

            }

        } else {

            for (int i = 0; i < editedLayers.size(); i++) {

                VectorialLayerEdited vle =

                    (VectorialLayerEdited) editedLayers.get(i);

                if (vle.equals(lyrEdit)) {

                    editedLayers.remove(i);

                    ile = null;

                    return;

                }

            }

        }

    }

    /* (non-Javadoc)

         * @see org.gvsig.editing.IEditionManager#getActiveLayerEdited()

         */

    public ILayerEdited getActiveLayerEdited() {

        return ile;

    }

    /* (non-Javadoc)

         * @see org.gvsig.editing.IEditionManager#getMapControl()

         */

    public MapControl getMapControl() {

        return mapCtrl;

    }

    /* (non-Javadoc)

         * @see org.gvsig.editing.IEditionManager#setMapControl(org.gvsig.fmap.mapcontrol.MapControl)

         */

    public void setMapControl(MapControl mapCtrl) {

        if (mapCtrl != null) {

            this.mapCtrl = mapCtrl;

            mapCtrl.getMapContext().getLayers().addLayerListener(this);

            mapCtrl.getMapContext().getLayers()

                .addLayerCollectionListener(this);

        }

    }

    public void layerAdded(LayerCollectionEvent e) {

        // Nothing to do

    }

    public void layerMoved(LayerPositionEvent e) {

        // Nothing to do

    }

    public void layerRemoved(LayerCollectionEvent e) {

        VectorialLayerEdited vle =

            (VectorialLayerEdited) getActiveLayerEdited();

        if (vle != null && vle.getLayer().isActive()) {

            try {

                vle.clearSelection();

            } catch (DataException e1) {

                NotificationManager.addError(e1);

            }

            editedLayers.remove(vle);

            getMapControl().setTool("zoomIn");

            FLyrVect lv = (FLyrVect) vle.getLayer();

            if (e.getAffectedLayer().equals(lv)) {

                IWindow window =

                    PluginServices.getMDIManager().getActiveWindow();

                if (window instanceof DefaultViewPanel) {

                    DefaultViewPanel view = (DefaultViewPanel) window;

                    view.hideConsole();

                    view.validate();

                    view.repaint();

                }

            }

        }

        PluginServices.getMainFrame().enableControls();

    }

    public void layerAdding(LayerCollectionEvent e) throws CancelationException {

        // Nothing to do

    }

    public void layerMoving(LayerPositionEvent e) throws CancelationException {

        // Nothing to do

    }

    public void layerRemoving(LayerCollectionEvent e)

        throws CancelationException {

        // Nothing to do

    }

    public void activationChanged(LayerCollectionEvent e)

        throws CancelationException {

        // Nothing to do

    }

    public void visibilityChanged(LayerCollectionEvent e)

        throws CancelationException {

        // Nothing to do

    }

    public void drawValueChanged(LayerEvent e) {

        // Nothing to do

    }

    public class DefaultCheckMandatoryAttributes extends AbstractFeatureRule

    implements CheckMandatoryAttributesRule {

        protected DefaultCheckMandatoryAttributes() {

            super("CheckMandatoryAttributtes", "CheckMandatoryAttributtes");

        }

        public void validate(Feature feature, FeatureStore featureStore)

            throws DataException {

            // Comprobar si hay campos obligatorios y presentar formulario

            FeatureType featureType = feature.getType();

            FeatureAttributeDescriptor[] attributeDescriptors =

                featureType.getAttributeDescriptors();

            boolean showForm = false;

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

                FeatureAttributeDescriptor attrDesc = attributeDescriptors[i];

                if (((attrDesc.isPrimaryKey() && !attrDesc.isAutomatic())|| !attrDesc.allowNull())

                    && feature.get(attrDesc.getName()) == null) {

                    showForm = true;

                    break;

                }

            }

            if (showForm) {

                askRequiredAttributtes((EditableFeature) feature, featureStore);

            }

        }

    }

    private void askRequiredAttributtes(final EditableFeature feature,

        final FeatureStore store)

        throws FeatureRuleMandatoryAttributesException {

        // Comprobar que estamos en el thread de swing y si no excepcion

        if (!SwingUtilities.isEventDispatchThread()) {

            try {

                SwingUtilities.invokeAndWait(new Runnable() {

                    public void run() {

                        askRequiredAttributtes(feature, store);

                    }

                });

            } catch (Exception e1) {

                throw new FeatureRuleMandatoryAttributesException(e1,

                    store.getFullName());

            }

            return;

        }

        DynObjectSwingManager dynObjectSwinManager =

            ToolsSwingLocator.getDynObjectSwingManager();

        final JDynObjectComponent dynObjectComponent;

        try {

            dynObjectComponent =

                dynObjectSwinManager.createJDynObjectComponent(

                    feature.getAsDynObject(), true);

        } catch (Exception e) {

            // TODO This has to be improved

            // Instead of this warning, show dialog to

            // fill feature type 

            showBadValuesMessage(e.getMessage());

            return;

        }

        final JPanel panel = new JPanel();

        ButtonsPanel buttonsPanel =

            new ButtonsPanel(ButtonsPanel.BUTTONS_ACCEPTCANCEL);

        buttonsPanel.addButtonPressedListener(new ButtonsPanelListener() {

            public void actionButtonPressed(ButtonsPanelEvent e) {

                if (e.getButton() == ButtonsPanel.BUTTON_ACCEPT) {

                    dynObjectComponent.saveStatus();

                    panel.setVisible(false);

                }

                if (e.getButton() == ButtonsPanel.BUTTON_CANCEL) {

                    panel.setVisible(false);

                    throw new FeatureRuleMandatoryAttributesException(store

                        .getFullName());

                }

            }

        });

        panel.setLayout(new BorderLayout());

        ScrollPane scrollPanel = new ScrollPane();

        scrollPanel.add(dynObjectComponent.asJComponent(), BorderLayout.CENTER);

        panel.add(scrollPanel);

        panel.add(buttonsPanel, BorderLayout.SOUTH);

        panel.setPreferredSize(new Dimension(800, 600));

        WindowManager wm = ToolsSwingLocator.getWindowManager();

        wm.showWindow(panel, "Fill mandatory fields", WindowManager.MODE.DIALOG);

    }

    /**

     * @param message

     */

    private void showBadValuesMessage(String message) {

        ApplicationLocator.getManager().message(

            message,

            JOptionPane.WARNING_MESSAGE);

        /*

         * We cannot do this because window focus

         * causes exception in drawing

         * 

        IWindow iw = PluginServices.getMDIManager().getActiveWindow();

        Component pare = null;

        if (iw instanceof Component) {

            pare = (Component) iw;

        }

        String _tit = Messages.getText("editing");

        String _msg = Messages.getText("_Invalid_values_in_some_fields_must_be_edited_before_end_editing");

        _msg = _msg + "\n\n[" + message + "]";

        JOptionPane.showMessageDialog(

            pare,

            _msg, _tit,

            JOptionPane.WARNING_MESSAGE);

            */

    }

    private void addCheckRules(FLyrVect layer) {

        try {

            FeatureType featureType =

                layer.getFeatureStore().getDefaultFeatureType();

            FeatureRules featureRules = featureType.getRules();

            for (Iterator it = featureRules.iterator(); it.hasNext();) {

                FeatureRule rule = (FeatureRule) it.next();

                if (rule instanceof CheckMandatoryAttributesRule) {

                    return;

                }

            }

            featureRules.add(new DefaultCheckMandatoryAttributes());

        } catch (DataException e) {

            throw new RuntimeException(e);

        }

    }

    public class FeatureRuleMandatoryAttributesException extends

        DataRuntimeException {

        private static final long serialVersionUID = -7965533441336164612L;

        private final static String MESSAGE_FORMAT =

            "Can't apply rule in store %(store)s.";

        private final static String MESSAGE_KEY =

            "_FeatureRuleMandatoryAttributesException";

        public FeatureRuleMandatoryAttributesException(Throwable cause,

            String store) {

            super(MESSAGE_FORMAT, cause, MESSAGE_KEY, serialVersionUID);

            this.setValue("store", store);

        }

        public FeatureRuleMandatoryAttributesException(String store) {

            super(MESSAGE_FORMAT, MESSAGE_KEY, serialVersionUID);

            this.setValue("store", store);

        }

    }

    private VectorialLayerEdited getVLE() {

        return (VectorialLayerEdited) getActiveLayerEdited();

    }

        private void insertSpatialCache(Geometry geom)

                        throws CreateEnvelopeException {

                VectorialLayerEdited vle = getVLE();

                SpatialCache spatialCache = ((FLyrVect) vle.getLayer())

                                .getSpatialCache();

                Envelope r = geom.getEnvelope();

                if (geom.getType() == Geometry.TYPES.POINT) {

                        r = geomManager.createEnvelope(r.getMinimum(0), r.getMinimum(1),

                                        r.getMinimum(0) + 1, r.getMinimum(1) + 1, SUBTYPES.GEOM2D);

                }

                spatialCache.insert(r, geom);

        }

        private void updateSpatialCache(Geometry geom) {

                // TODO: no se actualizaban la cache espacial cuando se modifican las geometrias,

                // habria que hacerlo.

                LOG.info("TODO: need update spatial cache");

        }

        private void removeSpatialCache(Geometry geom) {

                // TODO: no se actualizaban la cache espacial cuando se modifican las geometrias,

                // habria que hacerlo.

                LOG.info("TODO: need update spatial cache");

        }

    private void draw(Geometry geometry, Feature feature) {

        if (geometry != null) {

            getMapControl().getMapControlDrawer()

                .draw(geometry, mapControlManager.getGeometrySelectionSymbol());

        }

    }

    public Feature  insertGeometry(Geometry geometry) {

            VectorialLayerEdited vle = getVLE();

        try {

            FeatureStore featureStore =

                ((FLyrVect) vle.getLayer()).getFeatureStore();

            EditableFeature eFeature = featureStore.createNewFeature(true);

            //Reproject the geometry

            Geometry insertedGeometry = geometry;

            if (getVLE().getLayer().getCoordTrans() != null){

                insertedGeometry = insertedGeometry.cloneGeometry();

                insertedGeometry.reProject(getVLE().getLayer().getCoordTrans().getInverted());

            }

            eFeature.setGeometry(featureStore.getDefaultFeatureType()

                .getDefaultGeometryAttributeName(), insertedGeometry);

                EditionNotifycation notification = notifyObservers(EditionNotifycation.BEFORE_INSERT_FEATURE, getVLE().getLayer(), featureStore, eFeature);

                if( notification.isProcessCanceled() ) {

                        return null;

                }

            featureStore.insert(eFeature);

            insertSpatialCache(insertedGeometry);

            draw(insertedGeometry, eFeature);

                notifyObservers(EditionNotifycation.AFTER_INSERT_FEATURE, vle.getLayer(), featureStore, eFeature);

            return eFeature;

        } catch (Exception e) {

            NotificationManager.addError(e.getMessage(), e);

            return null;

        }

    }

    public Feature insertGeometry(Geometry geometry, Feature feature) {

        VectorialLayerEdited vle = getVLE();

        try {

            FeatureStore featureStore =

                ((FLyrVect) vle.getLayer()).getFeatureStore();

            EditableFeature eFeature =

                featureStore.createNewFeature(

                    featureStore.getDefaultFeatureType(), feature);

            eFeature.setGeometry(featureStore.getDefaultFeatureType()

                .getDefaultGeometryAttributeName(), geometry);

                EditionNotifycation notification = notifyObservers(EditionNotifycation.BEFORE_INSERT_FEATURE, getVLE().getLayer(), featureStore, feature);

                if( notification.isProcessCanceled() ) {

                        return null;

                }

            featureStore.insert(eFeature);

            insertSpatialCache(geometry);

            draw(geometry, eFeature);

            notifyObservers(EditionNotifycation.AFTER_INSERT_FEATURE, vle.getLayer(), featureStore, eFeature);

            return eFeature;

        } catch (Exception e) {

            NotificationManager.addError(e.getMessage(), e);

            return null;

        }

    }

    public Feature insertFeature(Feature feature) {

        VectorialLayerEdited vle = getVLE();

        try {

            FeatureStore featureStore =

                ((FLyrVect) vle.getLayer()).getFeatureStore();

            EditableFeature eFeature =

                featureStore.createNewFeature(

                    featureStore.getDefaultFeatureType(), feature);

            Geometry geometry = feature.getDefaultGeometry();

                EditionNotifycation notification = notifyObservers(EditionNotifycation.BEFORE_INSERT_FEATURE, getVLE().getLayer(), featureStore, feature);

                if( notification.isProcessCanceled() ) {

                        return null;

                }

                featureStore.insert(eFeature);

            insertSpatialCache(geometry);

            draw(geometry, eFeature);

            notifyObservers(EditionNotifycation.AFTER_INSERT_FEATURE, vle.getLayer(), featureStore, eFeature);

            return eFeature;

        } catch (Exception e) {

            NotificationManager.addError(e.getMessage(), e);

            return null;

        }

    }

    public Feature insertAndSelectGeometry(String toolName, Geometry geometry) {

        Feature feature = null;

        try {

            FeatureStore featureStore = getVLE().getFeatureStore();

            featureStore.beginComplexNotification();

            featureStore.beginEditingGroup(toolName);

            FeatureSelection newSelection =

                featureStore.createFeatureSelection();

            feature = insertGeometry(geometry);

            if( feature != null ) {

                    newSelection.select(feature);

                    featureStore.setSelection(newSelection);

            }

            featureStore.endEditingGroup();

            featureStore.endComplexNotification();

        } catch (DataException e) {

            NotificationManager.showMessageError("insertAndSelectGeoemtry", e);

        }

        return feature;

    }

    public EditableFeature updateGeometry(FeatureStore store, Feature feature, Geometry geometry) {

                try {

                        EditableFeature eFeature = feature.getEditable();

                        eFeature.setGeometry(feature.getType()

                                        .getDefaultGeometryAttributeName(), geometry);

                EditionNotifycation notification = notifyObservers(EditionNotifycation.BEFORE_UPDATE_FEATURE, getVLE().getLayer(), store, feature);

                if( notification.isProcessCanceled() ) {

                        return null;

                }

                        store.update(eFeature);

            updateSpatialCache(geometry);

                notifyObservers(EditionNotifycation.AFTER_UPDATE_FEATURE, getVLE().getLayer(), store, eFeature);

                return eFeature;

                } catch (Exception e) {

            NotificationManager.addError(e.getMessage(), e);

            return null;

                }

    }

    public EditableFeature updateFeature(FeatureStore store, Feature feature) {

                try {

                        EditableFeature eFeature = feature.getEditable();

                EditionNotifycation notification = notifyObservers(EditionNotifycation.BEFORE_UPDATE_FEATURE, getVLE().getLayer(), store, feature);

                if( notification.isProcessCanceled() ) {

                        return null;

                }

                        store.update(eFeature);

            updateSpatialCache(feature.getDefaultGeometry());

                notifyObservers(EditionNotifycation.AFTER_UPDATE_FEATURE, getVLE().getLayer(), store, eFeature);

                return eFeature;

                } catch (Exception e) {

            NotificationManager.addError(e.getMessage(), e);

            return null;

                }

    }

    public void removeFeature(FeatureStore store, Feature feature) {

                try {

                EditionNotifycation notification = notifyObservers(EditionNotifycation.BEFORE_REMOVE_FEATURE, getVLE().getLayer(), store, feature);

                if( notification.isProcessCanceled() ) {

                        return;

                }

                        store.delete(feature);

            removeSpatialCache(feature.getDefaultGeometry());

                notifyObservers(EditionNotifycation.AFTER_REMOVE_FEATURE, getVLE().getLayer(), store, feature);

                } catch (Exception e) {

            NotificationManager.addError(e.getMessage(), e);

                }

    }

        public void addObserver(Observer o) {

                observableHelper.addObserver(o);                

        }

        public void deleteObserver(Observer o) {

                observableHelper.deleteObserver(o);

        }

        public void deleteObservers() {

                observableHelper.deleteObservers();

        }

        private void notifyObservers(EditionNotifycation notifycation) {

                observableHelper.notifyObservers(this, notifycation);

        }

        private EditionNotifycation notifyObservers(int type, FLayer layer,

                        FeatureStore store, Feature feature) {

                DefaultEditionNotifycation notifycation = new DefaultEditionNotifycation(

                                type, layer, store, feature);

                try {

                        observableHelper.notifyObservers(this, notifycation);

                } catch (Exception ex) {

                        LOG.info("Can't notify observers", ex);

                }

                return notifycation;

        }

        class DefaultEditionNotifycation implements EditionNotifycation {

                private int type;

                private FLayer layer;

                private FeatureStore store;

                private Feature feature;

                private boolean processCanceled=false;

                DefaultEditionNotifycation(int type, FLayer layer, FeatureStore store, Feature feature) {

                        this.type = type;

                        this.layer = layer; 

                        this.store = store;

                        this.feature = feature;

                }

                public int getNotificationType() {

                        return type;

                }

                public FLyrVect getLayer() {

                        return (FLyrVect) layer;

                }

                public FeatureStore getStore() {

                        return store;

                }

                public Feature getFeature() {

                        return feature;

                }

                public void cancelProcess() {

                        processCanceled = true;

                }

                public boolean isProcessCanceled() {

                        return processCanceled;

                }

        }

           public void stopEditLayer(DefaultViewPanel view, FLyrVect lv, int mode)

               throws CancelEditingLayerException, ReadException {

               notifyObservers(EditionNotifycation.BEFORE_EXIT_EDIT_LAYER, lv, null, null);

                VectorialLayerEdited lyrEd = null;

                FeatureStore featureStore = null;

                switch (mode) {

                case CANCEL_EDITING:

                    lyrEd = (VectorialLayerEdited) this.getActiveLayerEdited();

                    lv.getFeatureStore().deleteObserver(lyrEd);

                    try {

                        featureStore = lv.getFeatureStore();

                        featureStore.cancelEditing();

                    } catch (ReadException e) {

                        throw new CancelEditingLayerException(lv.getName(), e);

                    } catch (DataException e) {

                        throw new CancelEditingLayerException(lv.getName(), e);

                    }

                    lv.getFeatureStore().deleteObserver(view);

                    lv.removeLayerListener(this);

                    if (view != null) {

                        view.getMapControl().getMapContext().removeLayerDrawListener(lyrEd);

                    }

                    break;

                case ACCEPT_EDITING:

                    lyrEd = (VectorialLayerEdited) this.getActiveLayerEdited();

                    lv.getFeatureStore().deleteObserver(lyrEd);

                    featureStore = lv.getFeatureStore();

                    try {

                        featureStore.finishEditing();

                    } catch (WriteException e) {

                        throw new ReadException(lv.getName(), e);

                    } catch (DataException e) {

                        throw new ReadException(lv.getName(), e);

                    }

                    lv.getFeatureStore().deleteObserver(view);

                    lv.removeLayerListener(this);

                    if (view != null) {

                        view.getMapControl().getMapContext().removeLayerDrawListener(lyrEd);

                    }

                    break;

                case CONTINUE_EDITING:

                    break;

                }

                  notifyObservers(EditionNotifycation.AFTER_EXIT_EDIT_LAYER, lv, null, null);

            }

}