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.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.order.impl.TrivialLayerOrderManager;

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;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 * Main executable class for testing the VectorEditing library.

 *

 * @author gvSIG Team

 * @version $Id$

 */

public class Main {

        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;

        TrivialLayerOrderManager layerOrderManager;

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

        AbstractAction polyline;

        AbstractAction polygon;

        AbstractAction symmetry;

        AbstractAction internalPolygon;

        public static void main(String args[]) {

                new DefaultLibrariesInitializer().fullInitialize();

                Main main = new Main();

                main.doMain();

        }

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

                layerOrderManager = new TrivialLayerOrderManager();

        }

        public void doMain() {

                try {

                        mapControl = mapControlManager.createJMapControlPanel();

//              editingBehavior = new DefaultEditingBehavior(editingContext, mapControl);

//              EditingCompoundBehavior editingCompoundBehavior = new EditingCompoundBehavior(editingBehavior);

//              mapControl.addBehavior("VectorEditing", editingCompoundBehavior);

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

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

        }

        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 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 polylineButton = new JButton(polyline);

                JButton symmetryButton = new JButton(symmetry);

                JButton internalPolygonButton = new JButton(internalPolygon);

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

                paletteTools.add(insertPointButton);

                paletteTools.add(circleCrButton);

                paletteTools.add(polylineButton);

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

        }

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

                menuTool.add(new JMenuItem(polygon));

                menuTool.add(new JMenuItem(symmetry));

                menuBar.add(menuFile);

                menuBar.add(menuTool);

                mainFrame.setJMenuBar(menuBar);

        }

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

                        }

                };

                circunferenceCr = new AbstractAction("CircunferenceCrAction") {

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

                        }

                };

        }

        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().setOrderManager(layerOrderManager);

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

                }

        }

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

                return this.addLayerFrame;

        }

}