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

import java.awt.BorderLayout;

import java.awt.Dimension;

import java.awt.GridLayout;

import java.awt.event.ActionEvent;

import java.io.File;

import java.util.ArrayList;

import java.util.List;

import javax.swing.AbstractAction;

import javax.swing.JButton;

import javax.swing.JFileChooser;

import javax.swing.JFrame;

import javax.swing.JMenu;

import javax.swing.JMenuBar;

import javax.swing.JMenuItem;

import javax.swing.JToolBar;

import javax.swing.SwingUtilities;

import javax.swing.WindowConstants;

import org.cresques.cts.IProjection;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.gvsig.fmap.crs.CRSFactory;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.DataStoreParameters;

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

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

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

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

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

import org.gvsig.fmap.mapcontext.MapContext;

import org.gvsig.fmap.mapcontext.MapContextLocator;

import org.gvsig.fmap.mapcontext.MapContextManager;

import org.gvsig.fmap.mapcontext.ViewPort;

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

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

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

import org.gvsig.fmap.mapcontrol.MapControl;

import org.gvsig.fmap.mapcontrol.MapControlCreationException;

import org.gvsig.fmap.mapcontrol.MapControlLocator;

import org.gvsig.fmap.mapcontrol.MapControlManager;

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

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

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

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

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

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

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

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

import org.gvsig.tools.library.impl.DefaultLibrariesInitializer;

import org.gvsig.tools.observer.Observable;

import org.gvsig.tools.observer.Observer;

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

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

import org.gvsig.utils.GenericFileFilter;

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

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

import org.gvsig.vectorediting.lib.prov.arc.ArcEditingProviderFactory;

import org.gvsig.vectorediting.lib.prov.autopolygon.AutopolygonEditingProviderFactory;

import org.gvsig.vectorediting.lib.prov.circle3p.Circle3PEditingProviderFactory;

import org.gvsig.vectorediting.lib.prov.circle3p.Circumference3PEditingProviderFactory;

import org.gvsig.vectorediting.lib.prov.circlecr.CircleCREditingProviderFactory;

import org.gvsig.vectorediting.lib.prov.circlecr.CircumferenceCREditingProviderFactory;

import org.gvsig.vectorediting.lib.prov.duplicate.DuplicateEditingProviderFactory;

import org.gvsig.vectorediting.lib.prov.ellipse.EllipseEditingProviderFactory;

import org.gvsig.vectorediting.lib.prov.explode.ExplodeEditingProviderFactory;

import org.gvsig.vectorediting.lib.prov.extendline.ExtendLineEditingProviderFactory;

import org.gvsig.vectorediting.lib.prov.internalpolygon.InternalPolygonEditingProviderFactory;

import org.gvsig.vectorediting.lib.prov.join.JoinEditingProviderFactory;

import org.gvsig.vectorediting.lib.prov.line.LineEditingProviderFactory;

import org.gvsig.vectorediting.lib.prov.move.MoveEditingProviderFactory;

import org.gvsig.vectorediting.lib.prov.multipoint.MultipointEditingProviderFactory;

import org.gvsig.vectorediting.lib.prov.point.PointEditingProviderFactory;

import org.gvsig.vectorediting.lib.prov.polyline.PolygonEditingProviderFactory;

import org.gvsig.vectorediting.lib.prov.polyline.PolylineEditingProviderFactory;

import org.gvsig.vectorediting.lib.prov.rectangle.FilledRectangleEditingProviderFactory;

import org.gvsig.vectorediting.lib.prov.rectangle.RectangleEditingProviderFactory;

import org.gvsig.vectorediting.lib.prov.rectangularmatrix.RectangularMatrixEditingProviderFactory;

import org.gvsig.vectorediting.lib.prov.regularpolygon.FilledRegularPolygonEditingProviderFactory;

import org.gvsig.vectorediting.lib.prov.regularpolygon.RegularPolygonEditingProviderFactory;

import org.gvsig.vectorediting.lib.prov.rotate.RotateEditingProviderFactory;

import org.gvsig.vectorediting.lib.prov.scale.ScaleEditingProviderFactory;

import org.gvsig.vectorediting.lib.prov.simplify.SimplifyEditingProviderFactory;

import org.gvsig.vectorediting.lib.prov.smoothline.SmoothLineEditingProviderFactory;

import org.gvsig.vectorediting.lib.prov.spline.FilledSplineEditingProviderFactory;

import org.gvsig.vectorediting.lib.prov.spline.SplineEditingProviderFactory;

import org.gvsig.vectorediting.lib.prov.split.SplitEditingProviderFactory;

import org.gvsig.vectorediting.lib.prov.splitline.SplitLineEditingProviderFactory;

import org.gvsig.vectorediting.lib.prov.trimline.TrimLineEditingProviderFactory;

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

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

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

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

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

import org.gvsig.vectorediting.swing.impl.DefaultEditingBehavior;

/**

 * Main executable class for testing the VectorEditing library.

 *

 * @author gvSIG Team

 * @version $Id$

 */

public class Main implements Observer {

    public static void main(String args[]) {

        new DefaultLibrariesInitializer().fullInitialize();

        Main main = new Main();

        main.doMain();

    }

    private static final Logger logger = LoggerFactory.getLogger(Main.class);

    final EditingManager manager;

    final EditingSwingManager swingManager;

    final EditingProviderManager providerManager;

    final MapControlManager mapControlManager;

    final DataManager dataManager;

    final MapContextManager mapContextManager;

    DefaultEditingBehavior editingBehavior;

    MapControl mapControl;

    EditingContext editingContext;

    FeatureStore store;

    FLyrVect currentLayer;

    final String DEFAULT_CRS_CODE = "EPSG:23030";

    IProjection defaultProjection;

    JFrame mainFrame;

    JFrame paletteTools;

    JButton openPaletteToolsButtons;

    JButton editingExtensionButtons;

    JButton endEditingExtensionButtons;

    JButton cleanMapButton;

    List<JButton> buttons;

    public Main() {

        manager = EditingLocator.getManager();

        swingManager = EditingSwingLocator.getSwingManager();

        providerManager = EditingProviderLocator.getProviderManager();

        mapControlManager = MapControlLocator.getMapControlManager();

        dataManager = DALLocator.getDataManager();

        mapContextManager = MapContextLocator.getMapContextManager();

        defaultProjection = CRSFactory.getCRS(DEFAULT_CRS_CODE);

        MapContextLocator

            .registerDefaultOrderManager(DummieLayerOrderManager.class);

    }

    public void addLayer(String shpPath) throws InitializeException,

        ProviderNotRegisteredException, ValidateDataParametersException,

        LoadLayerException {

        DataStoreParameters params;

        params = dataManager.createStoreParameters("Shape");

        String dbfPath =

            shpPath.substring(0, shpPath.length() - 3).concat("dbf");

        String shxPath =

            shpPath.substring(0, shpPath.length() - 3).concat("shx");

        File shpFile = new File(shpPath);

        File dbFile = new File(dbfPath);

        File shxFile = new File(shxPath);

        params.setDynValue("shpFile", shpFile.getPath());

        params.setDynValue("dbfFile", dbFile.getPath());

        params.setDynValue("shxFile", shxFile.getPath());

        params.setDynValue("CRS", defaultProjection);

        store = (FeatureStore) dataManager.openStore("Shape", params);

        FLayer layer = mapContextManager.createLayer(store.getName(), store);

        mapControl.getMapContext().getLayers().addLayer(layer);

        layer.setActive(true);

        try {

            currentLayer = (FLyrVect) layer;

        } catch (Exception e) {

            logger.error("Can't load layer " + e.getMessage());

        }

        refreshButtons();

    }

    private void createActionButtons() {

        buttons = new ArrayList<JButton>();

        buttons.add(new JButton(getPointAction()));

        buttons.add(new JButton(getMultiPointAction()));

        buttons.add(new JButton(getLineAction()));

        buttons.add(new JButton(getArcAction()));

        buttons.add(new JButton(getCircumferenceCrAction()));

        buttons.add(new JButton(getCircleCrAction()));

        buttons.add(new JButton(getCircumference3PAction()));

        buttons.add(new JButton(getCircle3PAction()));

        buttons.add(new JButton(getPolylineAction()));

        buttons.add(new JButton(getPolygonAction()));

        buttons.add(new JButton(getFilledEclipseAction()));

        buttons.add(new JButton(getRegularPolygonAction()));

        buttons.add(new JButton(getFilledRegularPolygonAction()));

        buttons.add(new JButton(getRectangleAction()));

        buttons.add(new JButton(getFilledRectangleAction()));

        buttons.add(new JButton(getSplineAction()));

        buttons.add(new JButton(getFilledSplineAction()));

        buttons.add(new JButton(getAutopolygonAction()));

        buttons.add(new JButton(getInternalPolygonAction()));

        buttons.add(new JButton(getExplodeGeometryAction()));

        buttons.add(new JButton(getMoveAction()));

        buttons.add(new JButton(getDuplicateAction()));

        buttons.add(new JButton(getRotateAction()));

        buttons.add(new JButton(getSplitLineAction()));

        buttons.add(new JButton(getSplitAction()));

        buttons.add(new JButton(getExtendLineAction()));

        buttons.add(new JButton(getTrimLineAction()));

        buttons.add(new JButton(getSimplifyAction()));

        buttons.add(new JButton(getScaleAction()));

        buttons.add(new JButton(getJoinAction()));

        buttons.add(new JButton(getSmoothLineAction()));

        buttons.add(new JButton(getRectangularMatrixAction()));

    }

    private JButton getOpenPaletteToolsButton() {

        if (openPaletteToolsButtons == null) {

            openPaletteToolsButtons = new JButton(getOpenPaletteToolsAction());

            openPaletteToolsButtons.setEnabled(false);

        }

        return openPaletteToolsButtons;

    }

    private JButton getEditingExtensionButton() {

        if (editingExtensionButtons == null) {

            editingExtensionButtons = new JButton(getEditingExtensionAction());

        }

        return editingExtensionButtons;

    }

    private JButton getEndEditingExtensionButton() {

        if (endEditingExtensionButtons == null) {

            endEditingExtensionButtons =

                new JButton(getEndEditingExtensionAction());

            endEditingExtensionButtons.setEnabled(false);

        }

        return endEditingExtensionButtons;

    }

    private JButton getCleanMapButton() {

        if (cleanMapButton == null) {

            cleanMapButton = new JButton(getCleanMapAction());

            cleanMapButton.setEnabled(false);

        }

        return cleanMapButton;

    }

    private AbstractAction getInternalPolygonAction() {

        return new AbstractAction("modify-internal-polygon") {

            /**

             *

             */

            private static final long serialVersionUID = -5366590032240258186L;

            public void actionPerformed(ActionEvent e) {

                editingContext = swingManager.getEditingContext(mapControl);

                editingContext

                    .activateService(InternalPolygonEditingProviderFactory.PROVIDER_NAME);

            }

        };

    }

    private AbstractAction getExplodeGeometryAction() {

        return new AbstractAction("modify-explode-geometry") {

            /**

             *

             */

            private static final long serialVersionUID = -5366590032240258186L;

            public void actionPerformed(ActionEvent e) {

                editingContext = swingManager.getEditingContext(mapControl);

                editingContext

                    .activateService(ExplodeEditingProviderFactory.PROVIDER_NAME);

            }

        };

    }

    private AbstractAction getMoveAction() {

        return new AbstractAction("modify-move") {

            /**

             *

             */

            private static final long serialVersionUID = -5366590032240258186L;

            public void actionPerformed(ActionEvent e) {

                editingContext = swingManager.getEditingContext(mapControl);

                editingContext

                    .activateService(MoveEditingProviderFactory.PROVIDER_NAME);

            }

        };

    }

    private AbstractAction getDuplicateAction() {

        return new AbstractAction("modify-duplicate") {

            /**

             *

             */

            private static final long serialVersionUID = -5366590032240258186L;

            public void actionPerformed(ActionEvent e) {

                editingContext = swingManager.getEditingContext(mapControl);

                editingContext

                    .activateService(DuplicateEditingProviderFactory.PROVIDER_NAME);

            }

        };

    }

    private AbstractAction getSimplifyAction() {

        return new AbstractAction("modify-simplify") {

            /**

             *

             */

            private static final long serialVersionUID = -5366590032240258186L;

            public void actionPerformed(ActionEvent e) {

                editingContext = swingManager.getEditingContext(mapControl);

                editingContext

                    .activateService(SimplifyEditingProviderFactory.PROVIDER_NAME);

            }

        };

    }

    private AbstractAction getFilledSplineAction() {

        return new AbstractAction("insert-filled-spline") {

            /**

             *

             */

            private static final long serialVersionUID = 357716596419507221L;

            public void actionPerformed(ActionEvent e) {

                editingContext = swingManager.getEditingContext(mapControl);

                editingContext

                    .activateService(FilledSplineEditingProviderFactory.PROVIDER_NAME);

            }

        };

    }

    private AbstractAction getSplineAction() {

        return new AbstractAction("insert-spline") {

            /**

             *

             */

            private static final long serialVersionUID = -2308770572409304622L;

            public void actionPerformed(ActionEvent e) {

                editingContext = swingManager.getEditingContext(mapControl);

                editingContext

                    .activateService(SplineEditingProviderFactory.PROVIDER_NAME);

            }

        };

    }

    private AbstractAction getFilledRectangleAction() {

        return new AbstractAction("insert-filled-rectangle") {

            /**

             *

             */

            private static final long serialVersionUID = 2293196006002423664L;

            public void actionPerformed(ActionEvent e) {

                editingContext = swingManager.getEditingContext(mapControl);

                editingContext

                    .activateService(FilledRectangleEditingProviderFactory.PROVIDER_NAME);

            }

        };

    }

    private AbstractAction getRectangleAction() {

        return new AbstractAction("insert-rectangle") {

            /**

             *

             */

            private static final long serialVersionUID = -6429005619655148416L;

            public void actionPerformed(ActionEvent e) {

                editingContext = swingManager.getEditingContext(mapControl);

                editingContext

                    .activateService(RectangleEditingProviderFactory.PROVIDER_NAME);

            }

        };

    }

    private AbstractAction getFilledRegularPolygonAction() {

        return new AbstractAction("insert-filled-regular-polygon") {

            /**

             *

             */

            private static final long serialVersionUID = 7944728685657584703L;

            public void actionPerformed(ActionEvent e) {

                editingContext = swingManager.getEditingContext(mapControl);

                editingContext

                    .activateService(FilledRegularPolygonEditingProviderFactory.PROVIDER_NAME);

            }

        };

    }

    private AbstractAction getRegularPolygonAction() {

        return new AbstractAction("insert-regular-polygon") {

            /**

             *

             */

            private static final long serialVersionUID = 1465569443777907186L;

            public void actionPerformed(ActionEvent e) {

                editingContext = swingManager.getEditingContext(mapControl);

                editingContext

                    .activateService(RegularPolygonEditingProviderFactory.PROVIDER_NAME);

            }

        };

    }

    private AbstractAction getPolygonAction() {

        return new AbstractAction("insert-polygon") {

            /**

             *

             */

            private static final long serialVersionUID = 966582628310445218L;

            public void actionPerformed(ActionEvent e) {

                editingContext = swingManager.getEditingContext(mapControl);

                editingContext

                    .activateService(PolygonEditingProviderFactory.PROVIDER_NAME);

            }

        };

    }

    private AbstractAction getPolylineAction() {

        return new AbstractAction("insert-polyline") {

            /**

             *

             */

            private static final long serialVersionUID = 2859732316623830924L;

            public void actionPerformed(ActionEvent e) {

                editingContext = swingManager.getEditingContext(mapControl);

                editingContext

                    .activateService(PolylineEditingProviderFactory.PROVIDER_NAME);

            }

        };

    }

    private AbstractAction getFilledEclipseAction() {

        return new AbstractAction("insert-ellipse") {

            /**

             *

             */

            private static final long serialVersionUID = -4698275458250358502L;

            public void actionPerformed(ActionEvent e) {

                editingContext = swingManager.getEditingContext(mapControl);

                editingContext

                    .activateService(EllipseEditingProviderFactory.PROVIDER_NAME);

            }

        };

    }

    private AbstractAction getCircumferenceCrAction() {

        return new AbstractAction("insert-circumference-cr") {

            /**

             *

             */

            private static final long serialVersionUID = -4422429984929119239L;

            public void actionPerformed(ActionEvent e) {

                editingContext = swingManager.getEditingContext(mapControl);

                editingContext

                    .activateService(CircumferenceCREditingProviderFactory.PROVIDER_NAME);

            }

        };

    }

    private AbstractAction getCircleCrAction() {

        return new AbstractAction("insert-circle-cr") {

            /**

             *

             */

            private static final long serialVersionUID = 1564163738941995373L;

            public void actionPerformed(ActionEvent e) {

                editingContext = swingManager.getEditingContext(mapControl);

                editingContext

                    .activateService(CircleCREditingProviderFactory.PROVIDER_NAME);

            }

        };

    }

    private AbstractAction getCircumference3PAction() {

        return new AbstractAction("insert-circumference-3p") {

            /**

             *

             */

            private static final long serialVersionUID = -4422429984929119239L;

            public void actionPerformed(ActionEvent e) {

                editingContext = swingManager.getEditingContext(mapControl);

                editingContext

                    .activateService(Circumference3PEditingProviderFactory.PROVIDER_NAME);

            }

        };

    }

    private AbstractAction getCircle3PAction() {

        return new AbstractAction("insert-circle-3p") {

            /**

             *

             */

            private static final long serialVersionUID = 1564163738941995373L;

            public void actionPerformed(ActionEvent e) {

                editingContext = swingManager.getEditingContext(mapControl);

                editingContext

                    .activateService(Circle3PEditingProviderFactory.PROVIDER_NAME);

            }

        };

    }

    private AbstractAction getArcAction() {

        return new AbstractAction("insert-arc") {

            /**

             *

             */

            private static final long serialVersionUID = 5529987067864211418L;

            public void actionPerformed(ActionEvent e) {

                editingContext = swingManager.getEditingContext(mapControl);

                editingContext

                    .activateService(ArcEditingProviderFactory.PROVIDER_NAME);

            }

        };

    }

    private AbstractAction getLineAction() {

        return new AbstractAction("insert-line") {

            /**

             *

             */

            private static final long serialVersionUID = 7464822491323014704L;

            public void actionPerformed(ActionEvent e) {

                editingContext = swingManager.getEditingContext(mapControl);

                editingContext

                    .activateService(LineEditingProviderFactory.PROVIDER_NAME);

            }

        };

    }

    private AbstractAction getPointAction() {

        return new AbstractAction("insert-point") {

            /**

             *

             */

            private static final long serialVersionUID = -9147590153911397886L;

            public void actionPerformed(ActionEvent e) {

                editingContext = swingManager.getEditingContext(mapControl);

                editingContext

                    .activateService(PointEditingProviderFactory.PROVIDER_NAME);

            }

        };

    }

    private AbstractAction getMultiPointAction() {

        return new AbstractAction("insert-multipoint") {

            /**

             *

             */

            private static final long serialVersionUID = -9147590153911397886L;

            public void actionPerformed(ActionEvent e) {

                editingContext = swingManager.getEditingContext(mapControl);

                editingContext

                    .activateService(MultipointEditingProviderFactory.PROVIDER_NAME);

            }

        };

    }

    private AbstractAction getSplitLineAction() {

        return new AbstractAction("modify-split-line") {

            /**

             *

             */

            private static final long serialVersionUID = -5366590032240258186L;

            public void actionPerformed(ActionEvent e) {

                editingContext = swingManager.getEditingContext(mapControl);

                editingContext

                    .activateService(SplitLineEditingProviderFactory.PROVIDER_NAME);

            }

        };

    }

    private AbstractAction getSplitAction() {

        return new AbstractAction("modify-split") {

            /**

             *

             */

            private static final long serialVersionUID = -5366590032240258186L;

            public void actionPerformed(ActionEvent e) {

                editingContext = swingManager.getEditingContext(mapControl);

                editingContext

                    .activateService(SplitEditingProviderFactory.PROVIDER_NAME);

            }

        };

    }

    private AbstractAction getExtendLineAction() {

        return new AbstractAction("modify-extend-line") {

            /**

             *

             */

            private static final long serialVersionUID = -5366590032240258186L;

            public void actionPerformed(ActionEvent e) {

                editingContext = swingManager.getEditingContext(mapControl);

                editingContext

                    .activateService(ExtendLineEditingProviderFactory.PROVIDER_NAME);

            }

        };

    }

    private AbstractAction getTrimLineAction() {

        return new AbstractAction("modify-trim-line") {

            /**

             *

             */

            private static final long serialVersionUID = -5366590032240258186L;

            public void actionPerformed(ActionEvent e) {

                editingContext = swingManager.getEditingContext(mapControl);

                editingContext

                    .activateService(TrimLineEditingProviderFactory.PROVIDER_NAME);

            }

        };

    }

    private AbstractAction getEndEditingExtensionAction() {

        return new AbstractAction("end-editing") {

            /**

             *

             */

            private static final long serialVersionUID = -1026680183527522379L;

            public void actionPerformed(ActionEvent e) {

                editingContext = swingManager.getEditingContext(mapControl);

                editingContext.endEdition(currentLayer);

                if (currentLayer != null && !currentLayer.isEditing()) {

                    getPaletteTools().setVisible(false);

                }

                refreshButtons();

            }

        };

    }

    private AbstractAction getRotateAction() {

        return new AbstractAction("modify-rotate") {

            /**

            *

            */

            private static final long serialVersionUID = -1026680183527522379L;

            public void actionPerformed(ActionEvent e) {

                editingContext = swingManager.getEditingContext(mapControl);

                editingContext

                    .activateService(RotateEditingProviderFactory.PROVIDER_NAME);

            }

        };

    }

    private AbstractAction getEditingExtensionAction() {

        return new AbstractAction("start-editing") {

            /**

             *

             */

            private static final long serialVersionUID = 5524271695550380473L;

            public void actionPerformed(ActionEvent e) {

                editingContext = swingManager.getEditingContext(mapControl);

                registerObserver(editingContext);

                editingContext.beginEdition(currentLayer, null);

                refreshButtons();

                // XXX Forces component repaint.

                SwingUtilities.updateComponentTreeUI(mainFrame);

            }

        };

    }

    private AbstractAction getExitAction() {

        return new AbstractAction("Exit") {

            /**

             *

             */

            private static final long serialVersionUID = 7506436995278783992L;

            public void actionPerformed(ActionEvent e) {

                System.exit(0);

            }

        };

    }

    private AbstractAction getOpenPaletteToolsAction() {

        return new AbstractAction("Show palette tools") {

            /**

             *

             */

            private static final long serialVersionUID = -2643193186380529723L;

            public void actionPerformed(ActionEvent e) {

                getPaletteTools().setVisible(true);

            }

        };

    }

    private AbstractAction getAddLayerAction() {

        return new AbstractAction("Add layer") {

            /**

             *

             */

            private static final long serialVersionUID = -7527908235576117027L;

            public void actionPerformed(ActionEvent e) {

                ThreadSafeDialogsManager dlgManager =

                    ToolsSwingLocator.getThreadSafeDialogsManager();

                File[] file =

                    dlgManager.showChooserDialog("Seleccione archivo SHP",

                        JFileChooser.OPEN_DIALOG, JFileChooser.FILES_ONLY,

                        false, new File(System.getProperty("user.home")),

                        new GenericFileFilter(new String[] { ".shp" },

                            "(*.shp)"), true);

                if (file != null) {

                    try {

                        addLayer(file[0].getAbsolutePath());

                    } catch (Exception ex) {

                        logger.warn("Problems adding layer", ex);

                    }

                }

            }

        };

    }

    private AbstractAction getCleanMapAction() {

        return new AbstractAction("Clean Map") {

            /**

             *

             */

            private static final long serialVersionUID = 5059847015866672405L;

            public void actionPerformed(ActionEvent e) {

                MapContext mapContext = mapControl.getMapContext();

                mapContext.beginAtomicEvent();

                while (mapContext.getLayers().getLayersCount() > 0) {

                    mapContext.getLayers().removeLayer(0);

                }

                mapContext.endAtomicEvent();

                currentLayer = null;

                refreshButtons();

            }

        };

    }

    private AbstractAction getZoomAllAction() {

        return new AbstractAction("Zoom all") {

            /**

             *

             */

            private static final long serialVersionUID = -1338436395515982258L;

            public void actionPerformed(ActionEvent e) {

                zoomAll();

            }

        };

    }

    private AbstractAction getZoomAction() {

        return new AbstractAction("Zoom") {

            /**

             *

             */

            private static final long serialVersionUID = -7231543178928614445L;

            public void actionPerformed(ActionEvent e) {

                mapControl.setTool("zoom");

            }

        };

    }

    private AbstractAction getPanAction() {

        return new AbstractAction("Pan") {

            /**

             *

             */

            private static final long serialVersionUID = -6520053841602571307L;

            public void actionPerformed(ActionEvent e) {

                mapControl.setTool("pan");

            }

        };

    }

    private AbstractAction getAutopolygonAction() {

        return new AbstractAction("insert-autopolygon") {

            /**

             *

             */

            private static final long serialVersionUID = -6520053841602571307L;

            public void actionPerformed(ActionEvent e) {

                editingContext = swingManager.getEditingContext(mapControl);

                editingContext

                    .activateService(AutopolygonEditingProviderFactory.PROVIDER_NAME);

            }

        };

    }

    private AbstractAction getJoinAction() {

        return new AbstractAction("modify-join") {

            /**

             *

             */

            private static final long serialVersionUID = -6520053841602571307L;

            public void actionPerformed(ActionEvent e) {

                editingContext = swingManager.getEditingContext(mapControl);

                editingContext

                    .activateService(JoinEditingProviderFactory.PROVIDER_NAME);

            }

        };

    }

    private AbstractAction getSmoothLineAction() {

        return new AbstractAction("modify-smooth-line") {

            /**

             *

             */

            private static final long serialVersionUID = 4659561526143686702L;

            public void actionPerformed(ActionEvent e) {

                editingContext = swingManager.getEditingContext(mapControl);

                editingContext

                    .activateService(SmoothLineEditingProviderFactory.PROVIDER_NAME);

            }

        };

    }

    private AbstractAction getScaleAction() {

        return new AbstractAction("modify-scale") {

            /**

             *

             */

            private static final long serialVersionUID = -6520053841602571307L;

            public void actionPerformed(ActionEvent e) {

                editingContext = swingManager.getEditingContext(mapControl);

                editingContext

                    .activateService(ScaleEditingProviderFactory.PROVIDER_NAME);

            }

        };

    }

    private AbstractAction getRectangularMatrixAction() {

        return new AbstractAction("modify-rectangular-matrix") {

            /**

             *

             */

            private static final long serialVersionUID = -6520053841602571307L;

            public void actionPerformed(ActionEvent e) {

                editingContext = swingManager.getEditingContext(mapControl);

                editingContext

                    .activateService(RectangularMatrixEditingProviderFactory.PROVIDER_NAME);

            }

        };

    }

    private void createMenu() {

        // Create the menu bar.

        JMenuBar menuBar = new JMenuBar();

        // Build the menu.

        JMenu menuFile = new JMenu("File");

        menuFile.add(new JMenuItem(getExitAction()));

        menuBar.add(menuFile);

        mainFrame.setJMenuBar(menuBar);

    }

    private JFrame getPaletteTools() {

        if (paletteTools == null) {

            paletteTools = new JFrame("Palette tools");

            paletteTools.setLayout(new GridLayout(0, 2, 1, 5));

            paletteTools.setLocation(0, 0);

            paletteTools

                .setDefaultCloseOperation(WindowConstants.HIDE_ON_CLOSE);

            for (JButton button : buttons) {

                paletteTools.add(button);

            }

            paletteTools.pack();

        }

        return paletteTools;

    }

    private void createToolBar() {

        JToolBar toolBar = new JToolBar();

        toolBar.add(new JButton(getAddLayerAction()));

        toolBar.add(getEditingExtensionButton());

        toolBar.add(getEndEditingExtensionButton());

        toolBar.add(new JButton(getPanAction()));

        toolBar.add(new JButton(getZoomAction()));

        toolBar.add(new JButton(getZoomAllAction()));

        toolBar.add(getCleanMapButton());

        toolBar.add(getOpenPaletteToolsButton());

        mainFrame.add(toolBar, BorderLayout.PAGE_START);

    }

    public void doMain() {

        try {

            MapContext mapContext =

                new MapContext(new ViewPort(defaultProjection));

            mapControl = mapControlManager.createJMapControlPanel(mapContext);

            mapControl

                .addBehavior("zoom", new Behavior[] {

                    new RectangleBehavior(new ZoomInListenerImpl(mapControl)),

                    new PointBehavior(

                        new ZoomOutRightButtonListener(mapControl)) });

            mapControl.addBehavior("pan", new MoveBehavior(new PanListenerImpl(

                mapControl)));

            mapControl.addBehavior("pointSelection",

                new Behavior[] { new PointBehavior(new PointSelectionListener(

                    mapControl)) });

            IProjection defaultProjection = CRSFactory.getCRS(DEFAULT_CRS_CODE);

            mapControl.getViewPort().setProjection(defaultProjection);

            mapControl.setTool("pan");

            swingManager.registerEditingContext(mapControl);

            // Create buttons

            createActionButtons();

        } catch (MapControlCreationException e) {

            logger.error("Can't create mapControl", e);

        }

        // Create JFrame to show data

        mainFrame = new JFrame("Editing test app");

        mainFrame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);

        mainFrame.setPreferredSize(new Dimension(800, 680));

        mainFrame.add(mapControl, BorderLayout.CENTER);

        // Create menu bar

        createMenu();

        // Create tools bar

        createToolBar();

        // Display the window.

        mainFrame.pack();

        mainFrame.setLocation(500, 0);

        mainFrame.setVisible(true);

    }

    private void registerObserver(EditingContext editingContext) {

        editingContext.addObserver(this);

    }

    private void refreshButtons() {

        // Refresh palette tool buttons

        for (JButton button : buttons) {

            String acctionCommand = button.getActionCommand();

            editingContext = swingManager.getEditingContext(mapControl);

            boolean enable = editingContext.isServiceCompatible(acctionCommand);

            button.setEnabled(enable);

        }

        // Refresh toolbar buttons

        if (currentLayer != null) {

            if (currentLayer.isEditing()) {

                getOpenPaletteToolsButton().setEnabled(true);

                getEditingExtensionButton().setEnabled(false);

                getEndEditingExtensionButton().setEnabled(true);

                getCleanMapButton().setEnabled(false);

            } else {

                getOpenPaletteToolsButton().setEnabled(false);

                getEditingExtensionButton().setEnabled(true);

                getEndEditingExtensionButton().setEnabled(false);

                getCleanMapButton().setEnabled(true);

            }

        } else {

            getOpenPaletteToolsButton().setEnabled(false);

            getEditingExtensionButton().setEnabled(false);

            getEndEditingExtensionButton().setEnabled(false);

            getCleanMapButton().setEnabled(false);

        }

    }

    private void zoomAll() {

        MapContext mapContext = mapControl.getMapContext();

        Envelope all = mapContext.getLayers().getFullEnvelope();

        logger.info("Full extdents " + all.toString());

        mapContext.getViewPort().setEnvelope(all);

        mapContext.invalidate();

    }

    public void update(Observable observable, Object notification) {

        if (observable instanceof EditingContext) {

            refreshButtons();

        }

    }

}