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.

====

Put into this folder the resources needed by your test classes.

This folder is added to the Tests classpath, so you can load any resources 

through the ClassLoader.

By default, in this folder you can find an example of log4j configuration,

prepared to log messages through the console, so logging works when you

run your tests classes.

<?xml version="1.0" encoding="ISO-8859-1" ?>

<!--

    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.

-->

<!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">

<!-- 

Log4J configuration file for unit tests execution.

 -->

<log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/">

	<!-- Appender configuration to show logging messages through the console -->

	<appender name="CONSOLE" class="org.apache.log4j.ConsoleAppender">

		<layout class="org.apache.log4j.PatternLayout">

			<param name="ConversionPattern" value="%d{HH:mm:ss,SSS} %-5p [%c{2}.%M()]\n  %m%n" />

		</layout>

	</appender>

	<!-- 

	Activate logging messages of DEBUG level of higher only for the

	org.gvsig.tools packages.

	You can put full classes names or packages instead, to configure

	logging for all the classes and subpackages of the package.

	-->

	<category name="org.gvsig.tools">

		<priority value="DEBUG" />

	</category>

	<category name="org.gvsig.vectorediting">

		<priority value="DEBUG" />

	</category>

	<!-- 

	By default, show only logging messages of INFO level or higher, 

	through the previously configured CONSOLE appender. 

	-->

	<root>

		<priority value="INFO" />

		<appender-ref ref="CONSOLE" />

	</root>

</log4j:configuration>

/**

 * 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.lib.impl;

import org.gvsig.fmap.dal.DALLibrary;

import org.gvsig.tools.library.AbstractLibrary;

import org.gvsig.tools.library.LibraryException;

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

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

public class DefaultEditingProviderLibrary extends AbstractLibrary {

    @Override

    public void doRegistration() {

        registerAsImplementationOf(EditingProviderLibrary.class);

        require(DALLibrary.class);

    }

    @Override

    protected void doInitialize() throws LibraryException {

        EditingProviderLocator

        .registerEditingProviderManager(DefaultEditingProviderManager.class);

    }

    @Override

    protected void doPostInitialize() throws LibraryException {

    }

}

/**

 * 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.lib.impl;

import java.util.List;

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

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

import org.gvsig.fmap.geom.Geometry;

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

import org.gvsig.fmap.mapcontext.rendering.legend.IVectorLegend;

import org.gvsig.tools.dynobject.DynClass;

import org.gvsig.tools.dynobject.DynObject;

import org.gvsig.tools.observer.BaseNotification;

import org.gvsig.tools.observer.Notification;

import org.gvsig.tools.observer.ObservableHelper;

import org.gvsig.tools.observer.Observer;

import org.gvsig.tools.service.AbstractService;

import org.gvsig.tools.service.Manager;

import org.gvsig.tools.service.ServiceException;

import org.gvsig.tools.service.spi.AbstractProviderServices;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

public class DefaultEditingService extends AbstractService implements EditingService {

    private final ObservableHelper observableHelper;

//    private final DynObject parameters;

//    public DefaultEditingService(EditingProvider provider, DynObject parameters) {

//        this.parameters = parameters;

//        this.provider = provider;

//        this.observableHelper = new ObservableHelper();

//    }

    DefaultEditingService(DynObject arg0, EditingProviderServices editingProviderServices) throws ServiceException {

        this.init(arg0, editingProviderServices);

        ((AbstractProviderServices)editingProviderServices).setService(this);

        this.observableHelper = new ObservableHelper();

    }

    @Override

    protected EditingProvider getProvider() {

        return (EditingProvider) super.getProvider();

    }

    @Override

    public Manager getManager() {

        return null;

    }

    @Override

    public DrawingStatus getDrawingStatus(Point mousePosition)

        throws DrawServiceException {

        return getProvider().getDrawingStatus(mousePosition);

    }

    @Override

    public List<EditingServiceParameter> getParameters() {

        return getProvider().getParameters();

    }

    @Override

    public EditingServiceParameter next() {

        EditingServiceParameter x = getProvider().next();

        this.updateObservers(NEXT_NOTIFICATION, x, null);

        return x;

    }

    @Override

    public void setValue(Object value) throws InvalidEntryException {

        getProvider().setValue(value);

        this.updateObservers(PARAMETER_CHANGED1_NOTIFICATION, value, null);

    }

    @Override

    public void stop() throws StopServiceException {

        getProvider().stop();

        this.updateObservers(STOP_NOTIFICATION, null, null);

    }

    @Override

    public void finishAndStore() throws FinishServiceException {

        getProvider().finishAndStore();

        this.updateObservers(FINISH_AND_STORE_NOTIFICATION, null, null);

    }

    @Override

    public Geometry finish() throws FinishServiceException {

        Geometry x = getProvider().finish();

        this.updateObservers(FINISH_NOTIFICATION, x, null);

        return x;

    }

    @Override

    public void start() throws StartServiceException, InvalidEntryException {

        this.getProvider().start();

        this.getProvider().initDefaultValues();

        this.updateObservers(START_NOTIFICATION, null, null);

    }

    @Override

    public String getName() {

        return getProvider().getName();

    }

    @Override

    public void setValue(EditingServiceParameter parameter, Object value) throws InvalidEntryException {

        getProvider().setValue(parameter, value);

        this.updateObservers(PARAMETER_CHANGED2_NOTIFICATION, parameter, value);

    }

    @Override

    public boolean isEnabled(EditingServiceParameter parameter) {

        return getProvider().isEnabled(parameter);

    }

    @Override

    public void activate() {

        getProvider().activate();

        this.updateObservers(ACTIVATE_NOTIFICATION, null, null);

    }

    @Override

    public Object getValue(EditingServiceParameter parameter) {

        return getProvider().getValue(parameter);

    }

    @Override

    public Object getValue(EditingServiceParameter parameter, EditingServiceParameter.TYPE type) {

        return getProvider().getValue(parameter, type);

    }

    @Override

    public void addObserver(Observer o) {

        this.observableHelper.addObserver(o);

    }

    @Override

    public void deleteObserver(Observer o) {

        this.observableHelper.deleteObserver(o);

    }

    @Override

    public void deleteObservers() {

        this.observableHelper.deleteObservers();

    }

    private void updateObservers(String type, Object v1, Object v2) {

        Notification notification =

            new BaseNotification(type,new Object[] {v1,v2});

        this.observableHelper.notifyObservers(this, notification);

    }

    @Override

    public void setDefaultFeatureValues(EditableFeature feature) {

        this.getProvider().setDefaultFeatureValues(feature);

    }

    @Override

    public EditableFeature getDefaultFeatureValues() {

        return this.getProvider().getDefaultFeatureValues();

    }

    @Override

    public FeatureStore getStore() {

        return (FeatureStore) this.getServiceParameters().getDynValue(EditingProviderFactory.FEATURE_STORE_FIELD);

    }

    @Override

    public IVectorLegend getLegend() {

        return (IVectorLegend) this.getServiceParameters().getDynValue(EditingProviderFactory.LEGEND_FIELD);

    }

    @Override

    public String getDescription() {

        String name = this.getProvider().getName();

        try {

            DynObject params = EditingLocator.getManager().createServiceParameters(name);

            DynClass dynclass = params.getDynClass();

            return dynclass.getDescription();

        } catch (ServiceException ex) {

            return name;

        }

    }

    @Override

    protected EditingProviderManager getProviderManager() {

        return EditingProviderLocator.getProviderManager();

    }

    @Override

    public void setShowPreviewSymbol(boolean showPreviewSymbol) {

        getProvider().setShowPreviewSymbol(showPreviewSymbol);

    }

    @Override

    public void restart() throws StartServiceException, InvalidEntryException ,StopServiceException {

        this.getProvider().restart();

        this.updateObservers(RESTART_NOTIFICATION, null, null);

    }

}

/**

 * 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.lib.impl;

import org.gvsig.fmap.dal.DALLibrary;

import org.gvsig.fmap.geom.GeometryLibrary;

import org.gvsig.tools.library.AbstractLibrary;

import org.gvsig.tools.library.LibraryException;

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

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

/**

 * Library for default implementation initialization and configuration.

 *

 * @author gvSIG team

 * @version $Id$

 */

public class DefaultEditingLibrary extends AbstractLibrary {

    @Override

    public void doRegistration() {

        registerAsImplementationOf(EditingLibrary.class);

        require(DALLibrary.class);

        require(GeometryLibrary.class);

    }

    @Override

    protected void doInitialize() throws LibraryException {

        EditingLocator.registerManager(DefaultEditingManager.class);

    }

    @Override

    protected void doPostInitialize() throws LibraryException {

        // Do nothing

    }

}

/**

 * 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.lib.impl;

import java.net.URL;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import java.util.Properties;

import java.util.function.Predicate;

import javax.json.JsonArray;

import javax.json.JsonObject;

import javax.json.JsonValue;

import org.apache.commons.lang3.StringUtils;

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

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

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

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

import org.gvsig.fmap.geom.DataTypes;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.GeometryCoercionContext;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryUtils;

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

import org.gvsig.fmap.mapcontext.rendering.symbols.ISymbol;

import org.gvsig.json.Json;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dataTypes.Coercion;

import org.gvsig.tools.dataTypes.DataTypeUtils;

import org.gvsig.tools.dynobject.DynObject;

import org.gvsig.tools.service.Service;

import org.gvsig.tools.service.ServiceException;

import org.gvsig.tools.service.spi.AbstractProviderManager;

import org.gvsig.tools.service.spi.Provider;

import org.gvsig.tools.service.spi.ProviderFactory;

import org.gvsig.tools.service.spi.ProviderServices;

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

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

import org.gvsig.tools.swing.icontheme.IconTheme;

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

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

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

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

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

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

public class DefaultEditingProviderManager extends AbstractProviderManager

implements EditingProviderManager {

    private static final Logger logger = LoggerFactory

        .getLogger(DefaultEditingProviderManager.class);

    Map<String, ISymbol> symbols = new HashMap<>();

    Map<String, Map<String, String>> defaultValues = new HashMap<>();

    private String clipboardValue;

    private List<Geometry> geometriesFromClipboard;

    private List<EditableFeature> featuresFromClipboard;

    public ProviderServices createProviderServices(Service service) {

        // TODO Auto-generated method stub

        return null;

    }

    @Override

    protected String getRegistryKey() {

        // TODO Auto-generated method stub

        return null;

    }

    @Override

    protected String getRegistryDescription() {

        // TODO Auto-generated method stub

        return null;

    }

    @Override

    public Provider createProvider(DynObject serviceParameters,

        ProviderServices providerServices) throws ServiceException {

        String providerName =

            (String) serviceParameters

            .getDynValue(EditingProviderFactory.PROVIDER_NAME_FIELD);

        ProviderFactory factory = getProviderFactory(providerName);

        return factory == null ? null : factory.create(serviceParameters,

            providerServices);

    }

    public EditingServiceInfo getServiceInfo(String name)

        throws ServiceInformationException {

        EditingProviderFactory factory;

        try {

            factory = (EditingProviderFactory) getProviderFactory(name);

            return (factory == null ? null : factory.getServiceInfo());

        } catch (Exception e) {

            throw new ServiceInformationException("Can't get service info of "

                + name, e);

        }

    }

    public void registerIcon(String group, String name, ClassLoader loader,

        String provider) {

        String resourceName;

        IconTheme iconTheme =

            ToolsSwingLocator.getIconThemeManager().getCurrent();

        if ((group == null) || (group.trim().length() == 0)) {

            resourceName = "images/" + name + ".png";

        } else {

            resourceName = "images/" + group + "/" + name + ".png";

        }

        URL resource = null;

        try {

            resource = loader.getResource(resourceName);

            iconTheme.registerDefault(provider, group, name, null, resource);

        } catch (Throwable e) {

            logger.info("Can't register icon '" + name + "'.", e);

        }

    }

    public void registerSymbol(String name, ISymbol symbol) {

        symbols.put(name, symbol);

    }

    public ISymbol getSymbol(String name) {

        return symbols.get(name);

    }

    public void registerDefaultValues(String provider, Map values) {

        if (!this.defaultValues.containsKey(provider)) {

            this.defaultValues.put(provider, values);

        }

    }

    public void registerDefaultValues(String provider, ClassLoader loader) {

        if (!this.defaultValues.containsKey(provider)) {

            String resourceName =

                "defaultvalues/" + provider + "/defaultvalues.properties";

            HashMap<String, String> providerDefaultValues =

                new HashMap<String, String>();

            URL resource = null;

            try {

                resource = loader.getResource(resourceName);

                Properties properties = new Properties();

                properties.load(resource.openStream());

                for (Iterator it = properties.keySet().iterator(); it.hasNext();) {

                    String key = (String) it.next();

                    providerDefaultValues.put(key, (String) properties.get(key));

                }

                this.defaultValues.put(provider, providerDefaultValues);

            } catch (Throwable e) {

                logger.info("Can't register default values from '" + provider

                    + "'.", e);

            }

        }

    }

    @Override

    public Map<String, String> getDefaultValues(String name) {

        return this.defaultValues.get(name);

    }

    @Override

    public List<Geometry> getGeometriesFromClipboard(){

        ToolsSwingManager manager = ToolsSwingLocator.getToolsSwingManager();

        String clipboardValue = manager.getFromClipboard();

        if(StringUtils.isNotBlank(clipboardValue) 

                && StringUtils.isNotBlank(this.clipboardValue)

                && StringUtils.equals(clipboardValue, this.clipboardValue)){

            return this.geometriesFromClipboard;

        }

        this.geometriesFromClipboard = new ArrayList<>();

        String geometryName = null;

        try {

            JsonArray jsonArray = Json.createArray(clipboardValue);

            Coercion toGeometry = ToolsLocator.getDataTypesManager().getCoercion(DataTypes.GEOMETRY);

            for (JsonValue item : jsonArray) {

                JsonObject jsonItem = (JsonObject) item;

                if (StringUtils.isBlank(geometryName)) {

                    for (Map.Entry<String, JsonValue> field : jsonItem.entrySet()) {

                        Geometry geometry;

                        try {

                            geometry = (Geometry) toGeometry.coerce(field.getValue().toString().replace("\"", ""));

                            if (geometry != null) {

                                geometryName = field.getKey();

                                this.geometriesFromClipboard.add(geometry);

                                break;

                            }

                        } catch (Exception e) {

                            //DO NOTHING

                        }

                    }

                } else {

                    Geometry geometry;

                    try {

                        String strGeom = jsonItem.getString(geometryName);

                        geometry = (Geometry) toGeometry.coerce(strGeom);

                        if (geometry != null) {

                            this.geometriesFromClipboard.add(geometry);

                        }

                    } catch (Exception e) {

                        //DO NOTHING

    //                        logger.warn("Can't coerce geometry", e);

                    }

                }

            }

        } catch (Exception ex) {

            //DO NOTHING

        }

        return this.geometriesFromClipboard;

    }

    @Override

    public List<EditableFeature> getFeaturesFromClipboard(EditingProviderServices providerServices, FeatureStore store) {

        ToolsSwingManager manager = ToolsSwingLocator.getToolsSwingManager();

        String clipboardValue = manager.getFromClipboard();

        if(StringUtils.isNotBlank(clipboardValue) 

                && StringUtils.isNotBlank(this.clipboardValue)

                && StringUtils.equals(clipboardValue, this.clipboardValue)){

            return this.featuresFromClipboard;

        }

        this.featuresFromClipboard = new ArrayList<>();

        GeometryType storeGeomType = store.getDefaultFeatureTypeQuietly().getDefaultGeometryAttribute().getGeomType();

        GeometryCoercionContext context = GeometryLocator.getGeometryManager().createGeometryCoercionContext();

        context.setGeometryType(storeGeomType);

        context.setMode(GeometryCoercionContext.MODE_ONERROR_NULL);

        Coercion toGeometry = DataTypeUtils.getCoercion(DataTypes.GEOMETRY);

        String geometryName = null;

        try {

            JsonArray jsonArray = Json.createArray(clipboardValue);

            for (JsonValue item : jsonArray) {

                JsonObject jsonItem = (JsonObject) item;

                EditableFeature feat = providerServices.createNewFeature(store);

                feat.setDefaultGeometry(null);

                feat.copyFrom(jsonItem, (FeatureAttributeDescriptor t) -> !(t.isPrimaryKey() || (t.isIndexed() && !t.allowIndexDuplicateds())));

                Geometry geometry = feat.getDefaultGeometry();

                if(geometry == null){

                    if (StringUtils.isBlank(geometryName)) {

                        for (Map.Entry<String, JsonValue> field : jsonItem.entrySet()) {

                            try {

                                geometry = (Geometry) toGeometry.coerce(field.getValue().toString().replace("\"", ""), context);

                                if (geometry != null) {

                                    geometryName = field.getKey();

                                    break;

                                }

                            } catch (Exception e) {

                                //DO NOTHING

                            }

                        }

                    } else {

                        try {

                            String strGeom = jsonItem.getString(geometryName);

                            geometry = (Geometry) toGeometry.coerce(strGeom, context);

                        } catch (Exception e) {

                            //DO NOTHING

                        }

                    }

                } else {

                    geometry = (Geometry) toGeometry.coerce(geometry,context);

                }

                if (geometry != null) {

                    feat.setDefaultGeometry(geometry);

                    this.featuresFromClipboard.add(feat);

                }

            }

        } catch (Exception ex) {

            //DO NOTHING

        }

        return this.featuresFromClipboard;

    }

}

/**

 * 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.lib.impl;

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

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

import org.gvsig.fmap.mapcontext.MapContext;

import org.gvsig.fmap.mapcontext.rendering.legend.IVectorLegend;

import org.gvsig.tools.dynobject.DynObject;

import org.gvsig.tools.service.AbstractManager;

import org.gvsig.tools.service.Service;

import org.gvsig.tools.service.ServiceException;

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.exceptions.ServiceInformationException;

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

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

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

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

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

public class DefaultEditingManager extends AbstractManager implements

EditingManager {

    private static final Logger logger = LoggerFactory

        .getLogger(DefaultEditingManager.class);

    public DefaultEditingManager() {

        super(new DefaultEditingProviderManager());

    }

    public Service getService(DynObject arg0) throws ServiceException {

        EditingProviderServices editingProviderServices = new DefaultEditingProviderServices();

        DefaultEditingService service = new DefaultEditingService(arg0, editingProviderServices);

//        DefaultEditingProviderServices editingProviderServices = new DefaultEditingProviderServices();

//        EditingProvider provider = (EditingProvider) EditingProviderLocator.getProviderManager()

//            .createProvider(arg0, editingProviderServices);

//        FeatureStore store = (FeatureStore) arg0.getDynValue(EditingProviderFactory.FEATURE_STORE_FIELD);

//        try {

//            editingProviderServices.setDefaultFeatureValues(store.createNewFeature());

//        } catch (DataException ex) {

//        }

//        DefaultEditingService service = new DefaultEditingService(provider, arg0);

//        editingProviderServices.setService(service);

        return service;

    }

    public EditingServiceInfo getServiceInfo(String serviceName)

        throws ServiceInformationException {

        return EditingProviderLocator.getProviderManager().getServiceInfo(

            serviceName);

    }

    @Override

    public EditingService getEditingService(String name,

        FeatureStore featureStore, MapContext mapContext, IVectorLegend legend) {

        try {

            DynObject params = this.createServiceParameters(name);

            params.setDynValue(EditingProviderFactory.FEATURE_STORE_FIELD,

                featureStore);

            params.setDynValue(EditingProviderFactory.MAPCONTEXT_FIELD, mapContext);

            if(legend != null && params.getDynClass().getDynField(EditingProviderFactory.LEGEND_FIELD)!=null){

                params.setDynValue(EditingProviderFactory.LEGEND_FIELD, legend);

            }

            return (EditingService) this.getService(params);

        } catch (ServiceException e) {

            String msg =

                String

                .format(

                    "Some problem getting %1$s editing service. Seems to name is not correct or there is not factory registered with that name. ",

                    name);

            logger.info(msg, e);

        }

        return null;

    }

    @Override

    public EditingService getEditingService(String name, FeatureStore featureStore, MapContext mapContext) {

        return getEditingService(name, featureStore, mapContext, null);

    }

}

/**

 * 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.lib.impl;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import java.util.Objects;

import org.gvsig.euclidean.EuclideanLine2D;

import org.gvsig.expressionevaluator.Expression;

import org.gvsig.expressionevaluator.ExpressionUtils;

import org.gvsig.expressionevaluator.GeometryExpressionBuilder;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.EditingNotification;

import org.gvsig.fmap.dal.EditingNotificationManager;

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

import org.gvsig.fmap.dal.expressionevaluator.DALExpressionBuilder;

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

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

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

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

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

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

import org.gvsig.fmap.dal.swing.DALSwingLocator;

import org.gvsig.fmap.geom.Geometry;

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

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryManager;

import org.gvsig.fmap.geom.GeometryUtils;

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

import org.gvsig.fmap.geom.operation.GeometryOperationException;

import org.gvsig.fmap.geom.operation.GeometryOperationNotSupportedException;

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

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

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

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

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

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

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

import org.gvsig.fmap.mapcontext.MapContext;

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

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

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

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

import org.gvsig.fmap.mapcontext.rendering.legend.IVectorLegend;

import org.gvsig.fmap.mapcontext.rendering.symbols.ISymbol;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.exception.BaseException;

import org.gvsig.tools.i18n.I18nManager;

import org.gvsig.tools.lang.CloneableUtils;

import org.gvsig.tools.service.spi.AbstractProviderServices;

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

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

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

import org.gvsig.vectorediting.lib.api.EditingServiceParameterOptions.ParameterOption;

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

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

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

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

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

public class DefaultEditingProviderServices extends AbstractProviderServices

        implements EditingProviderServices {

    private static final Logger LOGGER = LoggerFactory

            .getLogger(DefaultEditingProviderServices.class);

    public DefaultEditingProviderServices() {

        super();

    }

    @Override

    public void insertFeatureIntoFeatureStore(Feature feature,

            FeatureStore featureStore) {

        EditableFeature eFeature = null;

        try {

            if (feature instanceof EditableFeature) {

                eFeature = (EditableFeature) feature;

            } else {

                eFeature = feature.getEditable();

            }

            EditingNotificationManager editingNotificationManager

                    = DALSwingLocator.getEditingNotificationManager();

            EditingNotification notification

                    = editingNotificationManager.notifyObservers(this, // source

                            EditingNotification.BEFORE_INSERT_FEATURE, // type

                            null,// document

                            null,// layer

                            featureStore,// store

                            eFeature// feature

                    );

            if (notification.isCanceled()) {

                String msg

                        = String

                                .format(

                                        "Can't insert feature into %1$s, canceled by some observer.",

                                        featureStore.getName());

                throw new CancelationException(msg, null);

            }

            if (notification.shouldValidateTheFeature()) {

                if (!editingNotificationManager.validateFeature(eFeature)) {

                    String msg

                            = String.format("%1$s is not valid", eFeature.toString());

                    throw new Exception(msg);

                }

            }

            featureStore.insert(eFeature);

            editingNotificationManager.notifyObservers(this,

                    EditingNotification.AFTER_INSERT_FEATURE, null, null,

                    featureStore, eFeature);

        } catch (Exception e) {

            String msg

                    = String.format("Can't insert %1$s into %2$s",

                            eFeature.toString(), featureStore.getName());

            LOGGER.info(msg, e);

        }

    }

    @Override

    public EditableFeature createNewFeature(FeatureStore store){

        try {

            EditableFeature f = store.createNewFeature();

            //FIXME: ?Deber?amos saltarnos la geometr?a?

            f.copyFrom(this.getDefaultFeatureValues(),(FeatureAttributeDescriptor t) -> !(t.isPrimaryKey() || (t.isIndexed() && !t.allowIndexDuplicateds())));

            return f;

        } catch (DataException ex) {

            throw new RuntimeException("Can't create feature", ex);

        }

    }

    @Override

    public void insertGeometryIntoFeatureStore(Geometry geometry,

            FeatureStore featureStore) {

        EditableFeature eFeature = null;

        try {

            eFeature = this.createNewFeature(featureStore);

            eFeature.setGeometry(featureStore.getDefaultFeatureType()

                    .getDefaultGeometryAttributeName(), geometry);

            EditingNotificationManager editingNotificationManager

                    = DALSwingLocator.getEditingNotificationManager();

            EditingNotification notification

                    = editingNotificationManager.notifyObservers(this, // source

                            EditingNotification.BEFORE_INSERT_FEATURE, // type

                            null,// document

                            null,// layer

                            featureStore,// store

                            eFeature// feature

                    );

            if (notification.isCanceled()) {

                String msg

                        = String

                                .format(

                                        "Can't insert geometry into %1$s, canceled by some observer.",

                                        featureStore.getName());

                throw new CancelationException(msg, null);

            }

            if (notification.shouldValidateTheFeature()) {

                if (!editingNotificationManager.validateFeature(eFeature)) {

                    String msg

                            = String.format("%1$s is not valid", eFeature.toString());

                    throw new Exception(msg);

                }

            }

            featureStore.insert(eFeature);

            editingNotificationManager.notifyObservers(this,

                    EditingNotification.AFTER_INSERT_FEATURE, null, null,

                    featureStore, eFeature);

        } catch (Exception e) {

            String msg

                    = String.format("Can't insert %1$s into %2$s",

                            Objects.toString(eFeature), featureStore.getName());

            LOGGER.info(msg, e);

        }

    }

    @Override

    public void deleteFeatureFromFeatureSet(Feature feature,

            FeatureStore featureStore, FeatureSet set) {

        try {

            EditingNotificationManager editingNotificationManager

                    = DALSwingLocator.getEditingNotificationManager();

            EditingNotification notification

                    = editingNotificationManager.notifyObservers(this, // source

                            EditingNotification.BEFORE_REMOVE_FEATURE, // type

                            null,// document

                            null,// layer

                            featureStore,// store

                            feature// feature

                    );

            if (notification.isCanceled()) {

                String msg

                        = String

                                .format(

                                        "Can't delete feature from %1$s, canceled by some observer.",

                                        featureStore.getName());

                throw new CancelationException(msg, null);

            }

            set.delete(feature);

            editingNotificationManager.notifyObservers(this,

                    EditingNotification.AFTER_REMOVE_FEATURE, null, null,

                    featureStore, feature);

        } catch (Exception e) {

            LOGGER.warn(e.getMessage(), e);

        }

    }

    @Override

    public void deleteFeatureFromFeatureStore(Feature feature,

            FeatureStore featureStore) {

        try {

            EditingNotificationManager editingNotificationManager

                    = DALSwingLocator.getEditingNotificationManager();

            EditingNotification notification

                    = editingNotificationManager.notifyObservers(this, // source

                            EditingNotification.BEFORE_REMOVE_FEATURE, // type

                            null,// document

                            null,// layer

                            featureStore,// store

                            feature// feature

                    );

            if (notification.isCanceled()) {

                String msg

                        = String

                                .format(

                                        "Can't delete feature from %1$s, canceled by some observer.",

                                        featureStore.getName());

                throw new CancelationException(msg, null);

            }

            featureStore.delete(feature);

            editingNotificationManager.notifyObservers(this,

                    EditingNotification.AFTER_REMOVE_FEATURE, null, null,

                    featureStore, feature);

        } catch (Exception e) {

            LOGGER.warn(e.getMessage(), e);

        }

    }

    @Override

    public void updateFeatureInFeatureStore(Feature feature,

            FeatureStore featureStore) {

        EditableFeature eFeature = null;

        try {

            if (feature instanceof EditableFeature) {

                eFeature = (EditableFeature) feature;

            } else {

                eFeature = feature.getEditable();

            }

            EditingNotificationManager editingNotificationManager

                    = DALSwingLocator.getEditingNotificationManager();

            EditingNotification notification

                    = editingNotificationManager.notifyObservers(this, // source

                            EditingNotification.BEFORE_UPDATE_FEATURE, // type

                            null,// document

                            null,// layer

                            featureStore,// store

                            eFeature// feature

                    );

            if (notification.isCanceled()) {

                String msg

                        = String

                                .format(

                                        "Can't update feature in %1$s, canceled by some observer.",

                                        featureStore.getName());

                throw new CancelationException(msg, null);

            }

            if (notification.shouldValidateTheFeature()) {

                if (!editingNotificationManager.validateFeature(eFeature)) {

                    String msg

                            = String.format("%1$s is not valid", eFeature.toString());

                    throw new Exception(msg);

                }

            }

            featureStore.update(eFeature);

            editingNotificationManager.notifyObservers(this,

                    EditingNotification.AFTER_UPDATE_FEATURE, null, null,

                    featureStore, eFeature);

        } catch (Exception e) {

            String msg

                    = String.format("Can't update %1$s in %2$s", eFeature.toString(),

                            featureStore.getName());

            LOGGER.info(msg, e);

        }

    }

    @Override

    public Circle createCircle(Point center, double radius, int subtype)

            throws CreateGeometryException {

        return GeometryUtils.createCircle(center, radius, subtype);

    }

    @Override

    public Circle createCircle(Point firstPoint, Point secondPoint,

            Point thridPoint, int subtype) throws CreateGeometryException {

        return GeometryUtils.createCircle(firstPoint, secondPoint, thridPoint, subtype);

    }

    @Override

    public Arc createArc(Point center, double radius, double startAngle,

            double angleExt, int subtype) throws CreateGeometryException {

        return GeometryUtils.createArc(center, radius, startAngle, angleExt, subtype);

    }

    @Override

    public Ellipse createFilledEllipse(Point firstPointAxisA,

            Point secondPointAxisA, double halfLengthAxisB, int subtype)

            throws CreateGeometryException {

        return GeometryUtils.createFilledEllipse(firstPointAxisA, secondPointAxisA, halfLengthAxisB, subtype);

    }

    @Override

    public Arc createArc(Point start, Point middle, Point end, int subtype)

            throws BaseException {

        return GeometryUtils.createArc(start, middle, end, subtype);

    }

    @Override

    public Point createPoint(double x, double y, int subtype)

            throws CreateGeometryException {

        GeometryManager geomManager = GeometryLocator.getGeometryManager();

        return geomManager.createPoint(x, y, subtype);

    }

    @Override

    public Line createLine(double x1, double y1, double x2, double y2,

            int subtype) throws CreateGeometryException {

        return GeometryUtils.createLine(x1, y1, x2, y2, subtype);

    }

    @Override

    public int getSubType(FeatureStore featureStore) throws DataException {

        GeometryType geomType = getGeomType(featureStore);

        if (geomType != null) {

            return geomType.getSubType();

        }

        return SUBTYPES.UNKNOWN;

    }

    @Override

    public GeometryType getGeomType(FeatureStore featureStore)

            throws DataException {

        return featureStore.getDefaultFeatureType()

                .getDefaultGeometryAttribute().getGeomType();

    }

    @Override

    public EditableFeature getFeatureCopyWithoutUniqueIndex(FeatureStore featureStore,

            Feature feature) throws DataException {

        EditableFeature editableFeature

                = featureStore.createNewFeature(feature.getType(), true);

        editableFeature.copyFrom(this.getDefaultFeatureValues(), (FeatureAttributeDescriptor t) -> !(t.isPrimaryKey() || (t.isIndexed() && !t.allowIndexDuplicateds())));

        editableFeature.copyFrom(feature, (FeatureAttributeDescriptor t) -> !(t.isPrimaryKey() || (t.isIndexed() && !t.allowIndexDuplicateds())));

        return editableFeature;

    }

    @Override

    public Point getCenter(Point a, Point b, Point c, int subtype)

            throws CreateGeometryException {

        return GeometryUtils.getCenter(a, b, c, subtype);

    }

    @Override

    public Point getMidPoint(Point a, Point b, int subtype)

            throws CreateGeometryException {

        return GeometryUtils.getMidPoint(a, b, subtype);

    }

    @Override

    public Double[] getLineParams(Point point, Point nextPoint) {

        Double[] lineParams = new Double[2];

        double denom = nextPoint.getX() - point.getX();

        if (denom != 0) {

            lineParams[0] = (nextPoint.getY() - point.getY()) / denom;

            lineParams[1] = point.getY() - (lineParams[0] * point.getX());

        } else {

            if (nextPoint.getY() >= point.getY()) {

                lineParams[0] = Double.POSITIVE_INFINITY;

                lineParams[1] = Double.NEGATIVE_INFINITY;

                if (point.getX() == 0) {

                    lineParams[1] = 0.0;

                }

            } else {

                lineParams[0] = Double.NEGATIVE_INFINITY;

                lineParams[1] = Double.POSITIVE_INFINITY;

                if (point.getX() == 0) {

                    lineParams[1] = 0.0;

                }

            }

        }

        return lineParams;

    }

    @Override

    public Point[] getPerpendicular(Double m, Double b, Point point, int subtype)

            throws CreateGeometryException {

        // Pendiente de la recta perpendicular

        Double m1 = -1 / m;

        // b de la funcion de la recta perpendicular

        Double b1 = point.getY() - (m1 * point.getX());

        // Obtenemos un par de puntos

        Point[] res = new Point[2];

        if (Double.isInfinite(m1)) {

            if (m1 > 0) {

                //return the director vector of the line

                res[0] = createPoint(point.getX(), 0.0, subtype);

                res[1] = createPoint(point.getX(), 1.0, subtype);

            } else {

                res[0] = createPoint(point.getX(), 0.0, subtype);

                res[1] = createPoint(point.getX(), -1.0, subtype);

            }

        } else {

            //return the director vector of the line

            res[0] = createPoint(0.0, b1, subtype);

            Double mod = Math.sqrt(1 + Math.pow(m1, 2));

            Double x = 1 / mod;

            Double y = m1 * x + b1;

            res[1] = createPoint(x, y, subtype);

        }

        return res;

    }

    @Override

    public Point getIntersection(Point[] lineA, Point[] lineB, int subtype)

            throws CreateGeometryException {

        Point p1 = lineA[0];

        Point p2 = lineA[1];

        Point p3 = lineB[0];

        Point p4 = lineB[1];

        double m1 = Double.POSITIVE_INFINITY;

        if ((p2.getX() - p1.getX()) != 0) {

            m1 = (p2.getY() - p1.getY()) / (p2.getX() - p1.getX());

        }

        double m2 = Double.POSITIVE_INFINITY;

        if ((p4.getX() - p3.getX()) != 0) {

            m2 = (p4.getY() - p3.getY()) / (p4.getX() - p3.getX());

        }

        if ((m1 == Double.POSITIVE_INFINITY)

                && (m2 == Double.POSITIVE_INFINITY)) {

            return null;

        }

        double b1 = p2.getY() - (m1 * p2.getX());

        double b2 = p4.getY() - (m2 * p4.getX());

        if ((m1 != Double.POSITIVE_INFINITY)

                && (m2 != Double.POSITIVE_INFINITY)) {

            if (m1 == m2) {

                return null;

            }

            double x = (b2 - b1) / (m1 - m2);

            return createPoint(x, (m1 * x) + b1, subtype);

        } else if (m1 == Double.POSITIVE_INFINITY) {

            double x = p1.getX();

            return createPoint(x, (m2 * x) + b2, subtype);

        } else if (m2 == Double.POSITIVE_INFINITY) {

            double x = p3.getX();

            return createPoint(x, (m1 * x) + b1, subtype);

        }

        return null;

    }

    @Override

    public double getAngle(Point start, Point end)

            throws GeometryOperationNotSupportedException,

            GeometryOperationException {

        double angle

                = Math.acos((end.getX() - start.getX()) / start.distance(end));

        if (start.getY() > end.getY()) {

            angle = -angle;

        }

        if (angle < 0) {

            angle += (2 * Math.PI);

        }

        return angle;

    }

    @Override

    public double angleDistance(double angle1, double angle2) {

        double result = angle2 - angle1;

        if (result < 0) {

            result = (Math.PI * 2) + result;

        }

        return result;

    }

    @Override

    public Line createLine(Point p1, Point p2, int subtype)

            throws CreateGeometryException {

        return GeometryUtils.createLine(p1, p2, subtype);

    }

    @Override

    public Spline createSpline(List<Point> points, int subtype)

            throws CreateGeometryException {

        return GeometryUtils.createSpline(points, subtype);

    }

    @Override

    public String makeConsoleMessage(String preText, Map<String, String> options) {

        I18nManager i18nManager = ToolsLocator.getI18nManager();

        StringBuilder stb = new StringBuilder();

        if (preText != null) {

            stb.append(i18nManager.getTranslation(preText));

            stb.append(" ");

        }

        for (String option : options.keySet()) {

            stb.append("[");

            stb.append(option);

            stb.append("]");

            stb.append(i18nManager.getTranslation(options.get(option)));