Application: gvSIG desktop » gvSIG tools: Vector editing

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright (C) 2007-2012 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 javax.swing.AbstractAction;

import javax.swing.JButton;

import javax.swing.JFrame;

import javax.swing.JLabel;

import javax.swing.JMenu;

import javax.swing.JMenuBar;

import javax.swing.JMenuItem;

import javax.swing.JTextField;

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.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.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.vectorediting.lib.api.EditingLocator;

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

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

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

import org.gvsig.vectorediting.lib.prov.insertpoint.InsertPointEditingProviderFactory;

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

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

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

import org.gvsig.vectorediting.lib.prov.symmetry.SymmetryEditingProviderFactory;

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

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

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

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

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

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

/**

 * Main executable class for testing the VectorEditing library.

 *

 * @author gvSIG Team

 * @version $Id$

 */

public class Main {

    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;

    EditingBehavior editingBehavior;

    MapControl mapControl;

    EditingContext editingContext;

    FeatureStore store;

    FLyrVect currentLayer;

    final String DEFAULT_CRS_CODE = "EPSG:23030";

    IProjection defaultProjection;

    JFrame mainFrame;

    JFrame addLayerFrame;

    JFrame paletteTools;

    JTextField shpField;

    // Actions

    AbstractAction pan;

    AbstractAction zoom;

    AbstractAction zoomall;

    AbstractAction cleanMap;

    AbstractAction openAddLayerDialog;

    AbstractAction openPaletteTools;

    AbstractAction editingExtensionAction;

    AbstractAction endEditingExtensionAction;

    AbstractAction insertPoint;

    AbstractAction exit;

    AbstractAction addLayer;

    AbstractAction circleCr;

    AbstractAction circumferenceCr;

    AbstractAction polyline;

    AbstractAction polygon;

    AbstractAction symmetry;

    AbstractAction internalPolygon;

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

        if (shpPath.isEmpty()) {

            shpPath =

                "/home/lmarques/data/cartography/Andalucia/muni_andalucia.shp";

        }

        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("prueba", store);

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

        mapControl.getMapContext().getLayers().setActive(true);

        try {

            currentLayer = (FLyrVect) layer;

        } catch (Exception e) {

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

        }

    }

    @SuppressWarnings("serial")

    private void createActions() throws MapControlCreationException {

        pan = new AbstractAction("Pan") {

            public void actionPerformed(ActionEvent e) {

                mapControl.setTool("pan");

            }

        };

        zoom = new AbstractAction("Zoom") {

            public void actionPerformed(ActionEvent e) {

                mapControl.setTool("zoom");

            }

        };

        zoomall = new AbstractAction("Zoom all") {

            public void actionPerformed(ActionEvent e) {

                zoomAll();

            }

        };

        cleanMap = new AbstractAction("Clean Map") {

            public void actionPerformed(ActionEvent e) {

                MapContext mapContext = mapControl.getMapContext();

                mapContext.beginAtomicEvent();

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

                    mapContext.getLayers().removeLayer(0);

                }

                mapContext.endAtomicEvent();

            }

        };

        openAddLayerDialog = new AbstractAction("Add layer") {

            public void actionPerformed(ActionEvent e) {

                addLayerFrame.setVisible(true);

            }

        };

        openPaletteTools = new AbstractAction("Show palette tools") {

            public void actionPerformed(ActionEvent e) {

                paletteTools.setVisible(true);

            }

        };

        addLayer = new AbstractAction("OK") {

            public void actionPerformed(ActionEvent e) {

                String shpPath = shpField.getText();

                try {

                    addLayer(shpPath);

                } catch (Exception e1) {

                    logger.error("Problems adding layer");

                    e1.printStackTrace();

                }

                addLayerFrame.setVisible(false);

            }

        };

        exit = new AbstractAction("Exit") {

            public void actionPerformed(ActionEvent e) {

                System.exit(0);

            }

        };

        editingExtensionAction = new AbstractAction("EditingExtension") {

            public void actionPerformed(ActionEvent e) {

                editingContext = swingManager.getEditingContext(mapControl);

                editingContext.beginEdition(currentLayer, null);

                // XXX Forces component repaint.

                SwingUtilities.updateComponentTreeUI(mainFrame);

            }

        };

        endEditingExtensionAction = new AbstractAction("EndEditingExtension") {

            public void actionPerformed(ActionEvent e) {

                editingContext = swingManager.getEditingContext(mapControl);

                editingContext.endEdition(currentLayer);

            }

        };

        insertPoint = new AbstractAction("InsertPointAction") {

            public void actionPerformed(ActionEvent e) {

                editingContext = swingManager.getEditingContext(mapControl);

                editingContext

                    .activateService(InsertPointEditingProviderFactory.PROVIDER_NAME);

            }

        };

        circleCr = new AbstractAction("CircleCrAction") {

            public void actionPerformed(ActionEvent e) {

                editingContext = swingManager.getEditingContext(mapControl);

                editingContext

                    .activateService(CircleCREditingProviderFactory.PROVIDER_NAME);

            }

        };

        circumferenceCr = new AbstractAction("CircumferenceCrAction") {

            public void actionPerformed(ActionEvent e) {

                editingContext = swingManager.getEditingContext(mapControl);

                editingContext

                    .activateService(CircumferenceCREditingProviderFactory.PROVIDER_NAME);

            }

        };

        polyline = new AbstractAction("PolylineAction") {

            public void actionPerformed(ActionEvent e) {

                editingContext = swingManager.getEditingContext(mapControl);

                editingContext

                    .activateService(PolylineEditingProviderFactory.PROVIDER_NAME);

            }

        };

        polygon = new AbstractAction("PolygonAction") {

            public void actionPerformed(ActionEvent e) {

                editingContext = swingManager.getEditingContext(mapControl);

                editingContext

                    .activateService(PolygonEditingProviderFactory.PROVIDER_NAME);

            }

        };

        symmetry = new AbstractAction("SymmetryAction") {

            public void actionPerformed(ActionEvent e) {

                editingContext = swingManager.getEditingContext(mapControl);

                editingContext

                    .activateService(SymmetryEditingProviderFactory.PROVIDER_NAME);

            }

        };

        internalPolygon = new AbstractAction("InternalPolygonAction") {

            public void actionPerformed(ActionEvent e) {

                editingContext = swingManager.getEditingContext(mapControl);

                editingContext

                    .activateService(InternalPolygonEditingProviderFactory.PROVIDER_NAME);

            }

        };

    }

    private void createAddLayerJFrame() {

        addLayerFrame = new JFrame("Add layer");

        addLayerFrame.setLayout(new GridLayout(4, 2, 3, 3));

        addLayerFrame.setPreferredSize(new Dimension(400, 150));

        addLayerFrame.pack();

        addLayerFrame.setLocation(250, 250);

        addLayerFrame.setDefaultCloseOperation(WindowConstants.HIDE_ON_CLOSE);

        JLabel shpLabel = new JLabel("Archivo SHP");

        shpField = new JTextField();

        addLayerFrame.add(shpLabel);

        addLayerFrame.add(shpField);

        addLayerFrame.add(new JLabel());

        JButton aceptarButton = new JButton(addLayer);

        addLayerFrame.add(aceptarButton, BorderLayout.LINE_END);

    }

    private void createMenu() {

        // Create the menu bar.

        JMenuBar menuBar = new JMenuBar();

        // Build the menu.

        JMenu menuFile = new JMenu("File");

        menuFile.add(new JMenuItem(exit));

        JMenu menuLayer = new JMenu("Layer");

        menuLayer.add(new JMenuItem(openAddLayerDialog));

        menuLayer.add(new JMenuItem(pan));

        menuLayer.add(new JMenuItem(zoom));

        menuLayer.add(new JMenuItem(zoomall));

        menuLayer.add(new JMenuItem(cleanMap));

        JMenu menuTool = new JMenu("Tools");

        menuTool.add(new JMenuItem(editingExtensionAction));

        menuTool.add(new JMenuItem(endEditingExtensionAction));

        menuTool.addSeparator();

        menuTool.add(new JMenuItem(insertPoint));

        menuTool.add(new JMenuItem(circleCr));

        menuTool.add(new JMenuItem(circumferenceCr));

        menuTool.add(new JMenuItem(polyline));

        menuTool.add(new JMenuItem(polygon));

        menuTool.add(new JMenuItem(symmetry));

        menuBar.add(menuFile);

        menuBar.add(menuTool);

        mainFrame.setJMenuBar(menuBar);

    }

    private void createShowPaletteTools() {

        paletteTools = new JFrame("Palette tools");

        paletteTools.setLayout(new GridLayout(20, 1, 1, 5));

        paletteTools.setPreferredSize(new Dimension(200, 600));

        paletteTools.pack();

        paletteTools.setLocation(0, 0);

        paletteTools.setDefaultCloseOperation(WindowConstants.HIDE_ON_CLOSE);

        JButton insertPointButton = new JButton(insertPoint);

        JButton circleCrButton = new JButton(circleCr);

        JButton circumferenceCr = new JButton("circumferenceCr");

        JButton polylineButton = new JButton(polyline);

        JButton polygonButton = new JButton(polygon);

        JButton symmetryButton = new JButton(symmetry);

        JButton internalPolygonButton = new JButton(internalPolygon);

        paletteTools.add(new JLabel("Insert tools"));

        paletteTools.add(insertPointButton);

        paletteTools.add(circleCrButton);

        paletteTools.add(circumferenceCr);

        paletteTools.add(polylineButton);

        paletteTools.add(polygonButton);

        paletteTools.add(new JLabel("Modify tools"));

        paletteTools.add(symmetryButton);

        paletteTools.add(internalPolygonButton);

    }

    private void createToolBar() {

        JToolBar toolBar = new JToolBar();

        toolBar.add(new JButton(openAddLayerDialog));

        toolBar.add(new JButton(editingExtensionAction));

        toolBar.add(new JButton(endEditingExtensionAction));

        toolBar.add(new JButton(pan));

        toolBar.add(new JButton(zoom));

        toolBar.add(new JButton(zoomall));

        toolBar.add(new JButton(cleanMap));

        toolBar.add(new JButton(openPaletteTools));

        mainFrame.add(toolBar, BorderLayout.PAGE_START);

    }

    public void doMain() {

        try {

            mapControl = mapControlManager.createJMapControlPanel();

            mapControl

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

                    new RectangleBehavior(new ZoomInListenerImpl(mapControl)),

                    new PointBehavior(

                        new ZoomOutRightButtonListener(mapControl)) });

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

                mapControl)));

            IProjection defaultProjection = CRSFactory.getCRS(DEFAULT_CRS_CODE);

            mapControl.getViewPort().setProjection(defaultProjection);

            swingManager.registerEditingContext(mapControl);

            // Create actions

            createActions();

        } 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 JFrame to add layer

        createAddLayerJFrame();

        // create JFrame palette tools

        createShowPaletteTools();

        // Create menu bar

        createMenu();

        // Create tools bar

        createToolBar();

        // Display the window.

        mainFrame.pack();

        mainFrame.setLocation(500, 0);

        mainFrame.setVisible(true);

    }

    public JFrame getJFrame() {

        return this.addLayerFrame;

    }

    private void zoomAll() {

        MapContext mapContext = mapControl.getMapContext();

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

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

        mapContext.getViewPort().setEnvelope(all);

        mapContext.invalidate();

    }

}