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.swing.impl;

import java.awt.Color;

import java.awt.Graphics;

import java.awt.Image;

import java.awt.event.MouseEvent;

import java.awt.image.BufferedImage;

import java.util.Iterator;

import java.util.Set;

import java.util.Stack;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

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

import org.gvsig.fmap.geom.Geometry;

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

import org.gvsig.fmap.geom.type.GeometryType;

import org.gvsig.fmap.mapcontext.ViewPort;

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

import org.gvsig.fmap.mapcontrol.MapControlDrawer;

import org.gvsig.fmap.mapcontrol.MapControlLocator;

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

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

import org.gvsig.fmap.mapcontrol.tools.Listeners.ToolListener;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.i18n.I18nManager;

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

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

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

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

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

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

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

import org.gvsig.vectorediting.lib.api.exceptions.CreateEditingBehaviorException;

import org.gvsig.vectorediting.lib.api.exceptions.InvalidEntryException;

import org.gvsig.vectorediting.lib.api.exceptions.ParsePointException;

import org.gvsig.vectorediting.lib.api.exceptions.ParseValueException;

import org.gvsig.vectorediting.lib.api.exceptions.ServiceInformationException;

import org.gvsig.vectorediting.lib.api.exceptions.StartServiceException;

import org.gvsig.vectorediting.lib.api.exceptions.StopServiceException;

import org.gvsig.vectorediting.lib.api.exceptions.VectorEditingException;

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

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

public class DefaultEditingBehavior extends Behavior implements EditingBehavior {

    private static final Logger logger = LoggerFactory

        .getLogger(DefaultEditingBehavior.class);

    private Stack<EditingService> serviceStack;

    private EditingContext editingContext;

    private FLyrVect currentLayer;

    private EditingServiceParameter currentParam;

    private Point adjustedPoint;

    private static final Image imageCursor = new BufferedImage(32, 32,

        BufferedImage.TYPE_INT_ARGB);

    static {

        Graphics g = imageCursor.getGraphics();

        int size1 = 15;

        int x = 16;

        int y = 16;

        g.setColor(Color.MAGENTA);

        g.drawLine((x - size1), (y), (x + size1), (y));

        g.drawLine((x), (y - size1), (x), (y + size1));

        g.drawRect((x - 6), (y - 6), 12, 12);

        g.drawRect((x - 3), (y - 3), 6, 6);

    }

    public DefaultEditingBehavior(EditingContext editingContext)

        throws CreateEditingBehaviorException {

        if (editingContext.getMapControl() != null) {

            this.editingContext = editingContext;

            serviceStack = new Stack<EditingService>();

        }

    }

    public void activateService(String name) {

        EditingManager manager = EditingLocator.getManager();

        if (currentLayer != null) {

            EditingService service =

                (EditingService) manager.getEditingService(name,

                    currentLayer.getFeatureStore());

            if (service != null) {

                this.enableSelection(false);

                try {

                    service.start();

                } catch (StartServiceException e) {

                    logger.info(

                        String.format("Can't start the service %1$s",

                            service.getName()), e);

                    cleanBehavior();

                    return;

                }

                if (!serviceStack.isEmpty()

                    && !getActiveService().next().getTypes()

                        .contains(EditingServiceParameter.TYPE.GEOMETRY)) {

                    serviceStack.clear();

                }

                setActiveService(service);

                getNextParameter();

            }

        }

    }

    /**

     * Shows description of parameter on console.

     */

    private void askQuestion(EditingServiceParameter param) {

        showConsoleMessage("\n#" + param.getDescription() + " > ");

    }

    public void cleanBehavior() {

        serviceStack.clear();

        currentParam = null;

        this.enableSelection(false);

        editingContext.refreshMenusAndToolBars();

        I18nManager i18nManager = ToolsLocator.getI18nManager();

        showConsoleMessage("\n" + i18nManager.getTranslation("select_new_tool")

            + "\n");

    }

    private void showConsoleMessage(String text) {

        editingContext.showConsoleMessage(text);

    }

    @Override

    public ToolListener getListener() {

        return new ToolListener() {

            public boolean cancelDrawing() {

                return false;

            }

            public Image getImageCursor() {

                return imageCursor;

            }

        };

    }

    /**

     * Gets next parameter of {@link #activateService(String)} and sets

     * {@link #currentParam}. If currentParam is null means all service

     * parameters

     * have value and service doesn't need more values.

     */

    private void getNextParameter() {

        currentParam = getActiveService().next();

        if (currentParam == null) {

            finishService();

        } else {

            askQuestion(currentParam);

            if (currentParam.getTypes().contains(

                EditingServiceParameter.TYPE.SELECTION)) {

                enableSelection(true);

            } else if (currentParam.getTypes().contains(

                EditingServiceParameter.TYPE.GEOMETRY)) {

                editingContext.refreshMenusAndToolBars();

            }

        }

    }

    private EditingService getActiveService() {

        if (!serviceStack.isEmpty()) {

            return serviceStack.peek();

        }

        return null;

    }

    private void setActiveService(EditingService service) {

        serviceStack.add(service);

    }

    private void finishService() {

        EditingService lastService = serviceStack.pop();

        try {

            if (!serviceStack.isEmpty()

                && getActiveService().next().getTypes()

                    .contains(EditingServiceParameter.TYPE.GEOMETRY)) {

                Geometry geometry = lastService.finish();

                if (geometry != null) {

                    getActiveService().setValue(geometry);

                }

            } else {

                lastService.finishAndStore();

                editingContext.getMapControl().rePaintDirtyLayers();

                setActiveService(lastService);

            }

            lastService.stop();

            lastService.start();

        } catch (InvalidEntryException ex) {

            I18nManager i18nManager = ToolsLocator.getI18nManager();

            showConsoleMessage(i18nManager.getTranslation("invalid_option"));

        } catch (VectorEditingException ex) {

            logger.info("Can't finish " + lastService.getName(), ex);

            cleanBehavior();

            return;

        }

        getNextParameter();

    }

    public void mouseClicked(MouseEvent e) {

        ViewPort vp = editingContext.getMapControl().getViewPort();

        if (getActiveService() != null) {

            if (currentParam != null) {

                Set<TYPE> typesOfParam = currentParam.getTypes();

                if (typesOfParam.contains(TYPE.LIST_POSITIONS)

                    || typesOfParam.contains(TYPE.POSITION)) {

                    if (typesOfParam.contains(TYPE.LIST_POSITIONS)) {

                        if (e.getClickCount() == 2) {

                            finishService();

                            return;

                        }

                    }

                    Point point;

                    point = vp.convertToMapPoint(e.getX(), e.getY());

                    try {

                        getActiveService().setValue(point);

                    } catch (VectorEditingException ex) {

                        I18nManager i18nManager = ToolsLocator.getI18nManager();

                        showConsoleMessage(i18nManager

                            .getTranslation("invalid_option"));

                    }

                }

                getNextParameter();

            }

        }

    }

    public void mouseEntered(MouseEvent e) throws BehaviorException {

    }

    public void mouseMoved(MouseEvent e) throws BehaviorException {

        ViewPort vp = editingContext.getMapControl().getViewPort();

        adjustedPoint = vp.convertToMapPoint(e.getX(), e.getY());

    }

    public void mousePressed(MouseEvent e) throws BehaviorException {

    }

    public void mouseReleased(MouseEvent e) throws BehaviorException {

    }

    @SuppressWarnings("rawtypes")

    public void paintComponent(MapControlDrawer mapControlDrawer) {

        super.paintComponent(mapControlDrawer);

        if (getActiveService() == null || adjustedPoint == null) {

            return;

        }

        DrawingStatus helperGeo = null;

        try {

            helperGeo = getActiveService().getDrawingStatus(adjustedPoint);

        } catch (VectorEditingException e) {

            logger.info("An error ocurred when draw service geometries", e);

        }

        if (helperGeo != null) {

            for (Iterator iterator = helperGeo.getGeometries().iterator(); iterator

                .hasNext();) {

                Geometry geometry = (Geometry) iterator.next();

                editingContext

                    .getMapControl()

                    .getMapControlDrawer()

                    .draw(

                        geometry,

                        MapControlLocator.getMapControlManager()

                            .getAxisReferenceSymbol());

            }

        }

    }

    /**

     * Sets the layer received as parameter as {@link #currentLayer}

     * 

     * @param layer

     */

    public void setCurrentLayer(FLyrVect layer) {

        if (this.currentLayer != layer) {

            cleanBehavior();

            this.currentLayer = layer;

        }

    }

    /**

     * Processes console entries from console. Tries to process entry in each

     * type

     * of {@link #currentParam}. If there is some error, It will continue

     * checking. If entry has been processed, It will set value in

     * {@link #activeService}.

     * 

     * @param response

     *            Console entry.

     * @throws InvalidEntryException

     *             If console entries has not been able to

     *             process, it will throw an exception to indicate that entry is

     *             not

     *             valid.

     * @throws StopServiceException

     *             If there are some errors stopping service.

     */

    public void textEntered(String response) {

        if (response == null) {

            if (getActiveService() != null) {

                try {

                    getActiveService().stop();

                    serviceStack.pop();

                    if (getActiveService() != null) {

                        getNextParameter();

                    } else {

                        cleanBehavior();

                    }

                } catch (StopServiceException e) {

                    logger

                        .info("Can't stop " + getActiveService().getName(), e);

                    return;

                }

            }

        } else {

            if (currentParam != null) {

                Set<TYPE> types = currentParam.getTypes();

                Point point = null;

                Double value = null;

                boolean insertedValue = false;

                if (!insertedValue && types.contains(TYPE.POSITION)

                    || types.contains(TYPE.LIST_POSITIONS)) {

                    try {

                        point = parsePoint(response);

                        if (point != null) {

                            getActiveService().setValue(point);

                            insertedValue = true;

                        }

                    } catch (VectorEditingException e) {

                        // Do nothing to try other types

                    }

                }

                if (!insertedValue && types.contains(TYPE.VALUE)) {

                    try {

                        value = parseValue(response);

                        if (value != null) {

                            getActiveService().setValue(value);

                            insertedValue = true;

                        }

                    } catch (VectorEditingException e) {

                        // Do nothing to try other types

                    }

                }

                if (!insertedValue && types.contains(TYPE.OPTION)) {

                    try {

                        response = response.replace("\n", "");

                        if (response != null) {

                            getActiveService().setValue(response);

                            insertedValue = true;

                        }

                    } catch (VectorEditingException e) {

                        // Do nothing to try other types

                    }

                }

                if (!insertedValue && types.contains(TYPE.SELECTION)) {

                    if (response.equalsIgnoreCase("\n")) {

                        enableSelection(false);

                        insertedValue = true;

                        try {

                            getActiveService().setValue(

                                currentLayer.getFeatureStore()

                                    .getFeatureSelection().clone());

                        } catch (InvalidEntryException e) {

                            I18nManager i18nManager =

                                ToolsLocator.getI18nManager();

                            showConsoleMessage(i18nManager

                                .getTranslation("invalid_option"));

                        } catch (Exception e) {

                            logger.info("Can't access to selecction.", e);

                            cleanBehavior();

                            return;

                        }

                    }

                }

                if (!insertedValue) {

                    I18nManager i18nManager = ToolsLocator.getI18nManager();

                    showConsoleMessage(i18nManager

                        .getTranslation("invalid_option"));

                }

                getNextParameter();

            }

        }

    }

    /**

     * Parse String to value.

     * 

     * @param response

     *            String to be parsed.

     * @return Values of string.

     * @throws ParseValueException

     *             If there is error trying to parse <code>String</code>.

     */

    private Double parseValue(String response) throws ParseValueException {

        try {

            return Double.valueOf(response);

        } catch (Exception e) {

            throw new ParseValueException(e);

        }

    }

    /**

     * Parse String to point. Formats accepted: (x,y) and x,y.

     * 

     * @param response

     *            String to be parsed.

     * @return Point of string.

     * @throws ParsePointException

     *             If there is error trying to parse <code>String</code>.

     */

    private Point parsePoint(String response) throws ParsePointException {

        String[] numbers = new String[1];

        numbers[0] = response;

        numbers = response.split(",");

        if (numbers.length == 2) {

            if (numbers[0].startsWith("(") && numbers[1].endsWith(")\n")) { // CCS

                numbers[0] = numbers[0].replace("(", "");

                numbers[1] = numbers[1].replace(")\n", "");

            }

            double[] values;

            try {

                values =

                    new double[] { Double.parseDouble(numbers[0]),

                        Double.parseDouble(numbers[1]) };

            } catch (Exception e) {

                throw new ParsePointException(e);

            }

            Point point;

            try {

                point =

                    geomManager.createPoint(values[0], values[1], currentLayer

                        .getFeatureStore().getDefaultFeatureType()

                        .getDefaultGeometryAttribute().getGeomType()

                        .getSubType());

            } catch (Exception e) {

                throw new ParsePointException(e);

            }

            return point;

        } else {

            throw new ParsePointException(null);

        }

    }

    private void enableSelection(boolean enableSelection) {

        editingContext.enableSelection(enableSelection);

    }

    public boolean isServiceCompatible(String name)

        throws ServiceInformationException {

        EditingManager manager = EditingLocator.getManager();

        EditingServiceInfo serviceInfo = manager.getServiceInfo(name);

        GeometryType geoType = null;

        for (EditingService editingService : serviceStack) {

            if (editingService.next().getTypes()

                .contains(EditingServiceParameter.TYPE.GEOMETRY)) {

                int geometryType = editingService.next().getGeometryType();

                int subType = -1;

                try {

                    subType =

                        currentLayer.getFeatureStore().getDefaultFeatureType()

                            .getDefaultGeometryAttribute().getGeomType()

                            .getSubType();

                    geoType =

                        geomManager.getGeometryType(geometryType, subType);

                } catch (Exception e) {

                    String msg =

                        String

                            .format(

                                "Problems getting default feature"

                                    + " type of %1$s or getting geometry type of %2$s %3$s",

                                currentLayer.getName(), geometryType, subType);

                    throw new ServiceInformationException(msg, e);

                }

                return serviceInfo.isCompatibleWith(geoType)

                    && serviceInfo.createsNewGeometries();

            }

        }

        try {

            geoType =

                currentLayer.getFeatureStore().getDefaultFeatureType()

                    .getDefaultGeometryAttribute().getGeomType();

        } catch (DataException e) {

            String msg =

                String.format("Problems getting default "

                    + "feature type of %1$s", currentLayer.getName());

            throw new ServiceInformationException(msg, e);

        }

        return serviceInfo.isCompatibleWith(geoType);

    }

}