Application: gvSIG desktop

import javax.json.Json;

import javax.json.JsonArray;

import javax.json.JsonArrayBuilder;

import javax.json.JsonObject;

import org.gvsig.fmap.dal.feature.impl.DefaultFeature;

    public JsonArray toJSON() {

        // TODO: estaria bien hacer una implementacion alternativa que devolviese

        // un JsonArray basado en el FeatureSet/FeaturePagingHelper, asi no 

        // tendria que construirse en memoria el JSON entero.

        try {

            JsonArrayBuilder builder = Json.createArrayBuilder();

            this.accept(new Visitor() {

                @Override

                public void visit(Object obj) throws VisitCanceledException, BaseException {

                    DefaultFeature f = (DefaultFeature) obj;

                    JsonObject fjson = f.toJSON();

                    builder.add(fjson);

                }

            });

            return builder.build();        

        } catch (Exception ex) {

            throw new RuntimeException("Can't create JSON array.",ex);

        }

    }

import javax.json.JsonObject;

    public EditableFeature createNewFeature(JsonObject defaultValues) throws DataException {

        FeatureType ft = this.getDefaultFeatureType();

        EditableFeature f = this.createNewFeature(ft, false);

        f.copyFrom(defaultValues);

        return f;

    }

    @Override

import java.time.LocalDate;

import java.time.LocalDateTime;

import java.time.ZoneId;

import java.time.ZoneOffset;

import java.time.format.DateTimeFormatter;

import java.time.temporal.TemporalAccessor;

import javax.json.JsonNumber;

import javax.json.JsonObject;

import org.gvsig.fmap.dal.DataTypes;

import org.gvsig.fmap.geom.GeometryUtils;

import org.json.JSONObject;

    public void copyFrom(JsonObject values) {

        // iterate over the attributes and copy one by one

        for (FeatureAttributeDescriptor attr : this.getType()) {

            if (attr==null || attr.isAutomatic() || attr.isReadOnly() || attr.isComputed() ) {

                continue;

            }

            String attrname = attr.getName();

            if( !values.containsKey(attrname) ) {

                continue;

            }           

            Object value;

            try {

                switch( values.getValueType() ) {

                    case STRING:

                        switch(attr.getType()) {

                            case DataTypes.GEOMETRY:

                                value = GeometryUtils.createFrom(values.getString(attrname));

                                break;

                            case DataTypes.DATE:

                                try {

                                    TemporalAccessor x = DateTimeFormatter.ISO_DATE_TIME.parse(values.getString(attrname));

                                    LocalDateTime date = LocalDateTime.from(x);

//                                    value = Date.from(date.atZone(ZoneId.systemDefault()).toInstant());

                                    value = Date.from(date.toInstant(ZoneOffset.UTC));

                                } catch(Exception ex) {

                                    value = values.getString(attrname);

                                }

                                break;

                            case DataTypes.STRING:

                            default:

                                value = values.getString(attrname);

                                break;

                        }

                        break;

                    case NUMBER:

                        JsonNumber n = values.getJsonNumber(attrname);

                        switch(attr.getType()) {

                            case DataTypes.BIGDECIMAL:

                                value = n.bigDecimalValue();

                                break;

                            case DataTypes.BYTE:

                                value = n.bigDecimalValue();

                                break;

                            case DataTypes.FLOAT:

                            case DataTypes.DOUBLE:

                                value = n.doubleValue();

                                break;

                            case DataTypes.INT:

                                value = n.intValue();

                                break;

                            case DataTypes.LONG:

                                value = n.longValue();

                                break;

                            default:

                                value = n.toString();

                                break;

                        }

                        break;

                    case TRUE:

                        value = true;

                        break;

                    case FALSE:

                        value = false;

                        break;

                    case NULL:

                        value = null;

                        break;

                    default:

                        value = values.getString(attrname);

                        break;

                }

            } catch(Exception ex) {

                continue;

            }

            if (value == null && !attr.allowNull()) {

                continue;

            }

            try {

                set(attr.getIndex(), value);

            } catch(Throwable th) {

                // Ignore

            }

        }

    }

import java.time.format.DateTimeFormatter;

import java.util.Objects;

import javax.json.Json;

import javax.json.JsonObject;

import javax.json.JsonObjectBuilder;

    public JsonObject toJSON() {

        JsonObjectBuilder builder = Json.createObjectBuilder();

        FeatureType ft = this.getType();

        for (FeatureAttributeDescriptor desc : ft) {

            if (desc.isComputed()) {

                continue;

            }

            switch(desc.getType()) {

                case DataTypes.GEOMETRY:

                    {

                        try {

                            builder.add(desc.getName(), this.getGeometry(desc.getIndex()).convertToWKT());

                        } catch (Exception ex) {

                            throw new RuntimeException("Can't convert geometry to WKT.", ex);

                        }

                    }

                    break;

                case DataTypes.BOOLEAN:

                    builder.add(desc.getName(), this.getBoolean(desc.getIndex()));

                    break;

                case DataTypes.BYTE:

                    builder.add(desc.getName(), this.getByte(desc.getIndex()));

                    break;

                case DataTypes.INT:

                    builder.add(desc.getName(), this.getInt(desc.getIndex()));

                    break;

                case DataTypes.LONG:

                    builder.add(desc.getName(), this.getLong(desc.getIndex()));

                    break;

                case DataTypes.DOUBLE:

                    builder.add(desc.getName(), this.getDouble(desc.getIndex()));

                    break;

                case DataTypes.FLOAT:

                    builder.add(desc.getName(), this.getFloat(desc.getIndex()));

                    break;

                case DataTypes.DATE:

                    // Format date as ISO 8601

                    Date date = this.getDate(desc.getIndex());

                    String value = DateTimeFormatter.ISO_DATE_TIME.format(date.toInstant());

                    builder.add(desc.getName(), value);

                    break;

                default:

                    builder.add(desc.getName(), Objects.toString(this.get(desc.getIndex()),""));

            }

        }        

        return builder.build();

    }

            <groupId>org.glassfish</groupId>

            <artifactId>javax.json</artifactId>

            <scope>compile</scope>

        </dependency>

        <dependency>

import javax.json.JsonObject;

    public EditableFeature createNewFeature(JsonObject defaultValues) throws DataException {

        return null;

    }

    @Override

import javax.json.JsonObject;

    public EditableFeature createNewFeature(JsonObject defaultValues)

        throws DataException;

import javax.json.JsonObject;

	public void copyFrom(JsonObject source);	

import javax.json.JsonArray;

    public JsonArray toJSON();

        <dependency>

            <groupId>org.glassfish</groupId>

            <artifactId>javax.json</artifactId>

            <scope>compile</scope>

        </dependency>

        </dependency>        

        <dependency>

            <groupId>org.glassfish</groupId>

            <artifactId>javax.json</artifactId>

            <version>1.0.4</version>

            <scope>compile</scope>

import javax.json.JsonArray;

import org.gvsig.app.ApplicationManager;

import org.gvsig.app.project.documents.view.ViewDocument;

import org.gvsig.app.project.documents.view.ViewManager;

import org.gvsig.fmap.mapcontext.MapContext;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.i18n.I18nManager;

    private static final Logger LOGGER = LoggerFactory.getLogger(CopyFeaturesToClipboardExtension.class);

    public void initialize() {

        IconThemeHelper.registerIcon("action", "layer-modify-clipboard-copy", this);

    }

    public void execute(String actionCommand) {

        if (actionCommand.compareToIgnoreCase("layer-modify-clipboard-copy") != 0) {

            return;

        }

        ApplicationManager application = ApplicationLocator.getManager();

        ViewDocument viewdoc = (ViewDocument) application.getActiveDocument(ViewManager.TYPENAME);

        if( viewdoc == null ) {

            return;

        }

        MapContext mapContext = viewdoc.getMapContext();

        FLyrVect layer = mapContext.getLayers().getFirstActiveVectorLayer();

        if( layer==null ) {

            return;

        }

        try {

            FeatureSelection selection = layer.getFeatureStore().getFeatureSelection();

            JsonArray json = selection.toJSON();

            application.putInClipboard(json.toString());

            I18nManager i18n = ToolsLocator.getI18nManager();

            application.messageDialog(

                    i18n.getTranslation("_Number_of_features_copied_to_clipboard")

                        + ":   " + selection.getSize(),

                    null, 

                    i18n.getTranslation("_Copy_selected_features_to_clipboard"),

                    JOptionPane.INFORMATION_MESSAGE, 

                    "CopyFeaturesToClipboard"

            );

        } catch (Exception e) {

            LOGGER.warn("Can't get the selection as JSON.", e);

        }

    }

    public boolean isEnabled() {

        // it's enabled if there is exactly one vector layer in the active view

        // and it has a selection

        ApplicationManager application = ApplicationLocator.getManager();

        ViewDocument viewdoc = (ViewDocument) application.getActiveDocument(ViewManager.TYPENAME);

        if( viewdoc == null ) {

            return false;

        }

        MapContext mapContext = viewdoc.getMapContext();

        FLyrVect layer = mapContext.getLayers().getFirstActiveVectorLayer();

        if( layer==null ) {

            return false;

        }

        if (!layer.isAvailable()) {

            // This can happen when opening a persisted project

            // and there is a "slow" layer (GeoDB)

            return false;

        }

        try {

            FeatureSelection selection = layer.getFeatureStore().getFeatureSelection();

            return !selection.isEmpty();

        } catch (Exception ex) {

            LOGGER.warn("Can't get selection from layer '"+layer.getName()+"'.", ex);

            return false;

        }

    }

    public boolean isVisible() {

        ApplicationManager application = ApplicationLocator.getManager();

        return application.getActiveDocument(ViewManager.TYPENAME)!=null;

    }

import com.vividsolutions.jts.io.ByteArrayInStream;

import java.io.ByteArrayInputStream;

import java.io.InputStream;

import java.io.StringReader;

import java.util.function.Predicate;

import org.apache.commons.lang.mutable.MutableInt;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.app.ApplicationManager;

import org.gvsig.app.project.documents.view.ViewManager;

import org.gvsig.fmap.geom.GeometryUtils;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.i18n.I18nManager;

import org.gvsig.tools.logger.FilteredLogger;

import org.json.JSONArray;

import org.json.JSONObject;

import javax.json.JsonObject;

import javax.json.Json;

import javax.json.JsonArray;

import javax.json.JsonReader;

import org.apache.commons.io.Charsets;

    private static final Logger LOGGER = LoggerFactory.getLogger(PasteFeaturesFromClipboardExtension.class);

    public void initialize() {

        IconThemeHelper.registerIcon("action", "layer-modify-clipboard-paste", this);

    }

    public void execute(String actionCommand) {

        if (actionCommand.compareToIgnoreCase("layer-modify-clipboard-paste") != 0) {

            return;

        }

        ApplicationManager application = ApplicationLocator.getManager();

        ViewDocument viewdoc = (ViewDocument) application.getActiveDocument(ViewManager.TYPENAME);

        if( viewdoc == null ) {

            return;

        }

        I18nManager i18n = ToolsLocator.getI18nManager();

        String clipboardValue = application.getFromClipboard();

        if( StringUtils.isBlank(clipboardValue) ) {

            application.messageDialog(

                i18n.getTranslation("_Clipboard_has_no_valid_info_or_is_empty"),

                null, 

                i18n.getTranslation("_Pasting_features_from_clipboard"),

                JOptionPane.INFORMATION_MESSAGE, 

                "ClipboardEmptyWhenPasteFeatures"

            );

            return;

        }

        JsonArray jsonArray;

        try {

            JsonReader jsonReader = Json.createReader(new StringReader(clipboardValue));

            jsonArray = jsonReader.readArray();

            jsonReader.close();

        } catch(Exception ex) {

            LOGGER.warn("Can't get JSON from the clipboard.", ex);

            application.messageDialog(

                i18n.getTranslation("_Clipboard_has_no_valid_info_or_is_empty"),

                null, 

                i18n.getTranslation("_Pasting_features_from_clipboard"),

                JOptionPane.WARNING_MESSAGE, 

                "ClipboardNotValidWhenPasteFeatures"

            );

            return;

        }

        if( jsonArray.size()<1 ) {

            application.messageDialog(

                i18n.getTranslation("_No_features_found_in_clipboard"),

                null, 

                i18n.getTranslation("_Pasting_features_from_clipboard"),

                JOptionPane.WARNING_MESSAGE, 

                "ClipboardNotHasElementsWhenPasteFeatures"

            );

            return;

        }

        MapContext mapContext = viewdoc.getMapContext();

        List<FLayer> layers = mapContext.getLayers().getLayers(new Predicate<FLayer>() {

            @Override

            public boolean test(FLayer layer) {

                return layer instanceof FLyrVect && 

                        layer.isActive() &&

                        layer.isAvailable() &&

                        layer.isEditing(); 

            }

        });

        if( layers.isEmpty() ) {

            return;

        }

        FLyrVect layer = (FLyrVect) layers.get(0);

        FeatureStore store = layer.getFeatureStore();

        List<EditableFeature> features = new ArrayList<>();

        FilteredLogger theLogger = new FilteredLogger(LOGGER, "PasteFeatures", 10);

        for (Object obj : jsonArray) {

            if( !(obj instanceof JsonObject ) ) {

                continue;

            }

            JsonObject fjson = (JsonObject) obj;

            try {

                EditableFeature f = store.createNewFeature(fjson);

                features.add(f);

            } catch (Exception ex) {

                theLogger.warn("Can't create feature from JSON.", ex);

            }

        }

        if( features.isEmpty() ) {

            application.messageDialog(

                i18n.getTranslation("_No_features_found_in_clipboard"),

                null, 

                i18n.getTranslation("_Pasting_features_from_clipboard"),

                JOptionPane.WARNING_MESSAGE, 

                "ClipboardNotHasFeaturesWhenPasteFeatures"

            );

            return;

        }

        int inserteds = 0;

        theLogger = new FilteredLogger(LOGGER, "PasteFeatures", 10);

        Envelope envelope = GeometryUtils.createEnvelope(Geometry.SUBTYPES.GEOM2D);

        for (EditableFeature feature : features) {

            try {

                store.insert(feature);

                inserteds++;

                try {

                    envelope.add(feature.getDefaultGeometry());

                } catch(Exception ex) {

                    theLogger.warn("Can't calculate envelope.", ex);

                }

            } catch(Exception ex) {

                theLogger.warn("Can't insert feature.", ex);

            }

        }

        StringBuilder msg = new StringBuilder();

        msg.append(i18n.getTranslation("_Number_of_features_pasted_from_clipboard"));

        msg.append(":   ");

        msg.append(inserteds);

        msg.append("\n");

        msg.append(i18n.getTranslation("_Number_of_features_from_clipboard_discarded_due_to_bad_format"));

        msg.append(":   ");

        msg.append(jsonArray.size() - inserteds);

        if( inserteds<1 || envelope.isEmpty() ) {

            application.messageDialog(

                msg.toString(),

                null, 

                i18n.getTranslation("_Pasting_features_from_clipboard"),

                JOptionPane.WARNING_MESSAGE, 

                "ClipboardNotInsertFeaturesWhenPasteFeatures"

            );

            return;

        }

        msg.append("\n\n");

        msg.append(i18n.getTranslation("_Zoom_to_added_features_question"));

        int r = application.confirmDialog(

                msg.toString(), 

                i18n.getTranslation("_Pasting_features_from_clipboard"),

                JOptionPane.YES_NO_OPTION, 

                JOptionPane.QUESTION_MESSAGE, 

                "ZoomToInsertedFeaturesWhenPasteFeatures"

        );

        if( r == JOptionPane.NO_OPTION ) {

            return;

        }

        try {

            viewdoc.getMapContext().getViewPort().setEnvelope(envelope);

        } catch(Exception ex) {

            LOGGER.warn("Can't zoom to envelope.", ex);

        }

    }

    public boolean isEnabled() {

        ApplicationManager application = ApplicationLocator.getManager();

        ViewDocument viewdoc = (ViewDocument) application.getActiveDocument(ViewManager.TYPENAME);

        if( viewdoc == null ) {

        }

        String clipboardValue = application.getFromClipboard();

        if( StringUtils.isBlank(clipboardValue) ) {

            return false;

        }

        MapContext mapContext = viewdoc.getMapContext();

        MutableInt numActiveVectorial = new MutableInt(0);

        MutableInt numActiveVectorialEditable = new MutableInt(0);

        List<FLayer> layers = mapContext.getLayers().getLayers(new Predicate<FLayer>() {

            @Override

            public boolean test(FLayer layer) {

                if (layer instanceof FLyrVect && 

                        layer.isActive() && 

                        layer.isAvailable() ) {

                        numActiveVectorial.increment();

                    if (layer.isEditing()) {

                        numActiveVectorialEditable.increment();

                    }

                // No recuperamos ninguna capa, solo contamos las activa en edicion

                return false; 

        });

        if (numActiveVectorialEditable.intValue() == 1 && 

                numActiveVectorial.intValue() == 1) {

            return true;

        }

        return false;

    }

    public boolean isVisible() {

        ApplicationManager application = ApplicationLocator.getManager();

        return application.getActiveDocument(ViewManager.TYPENAME)!=null;

    }

            <scope>compile</scope>

        <dependency>

            <groupId>org.glassfish</groupId>

            <artifactId>javax.json</artifactId>

            <scope>compile</scope>

        </dependency>

        </dependency>        

                <groupId>org.glassfish</groupId>

                <artifactId>javax.json</artifactId>

                <version>1.0.4</version>

            </dependency>

            <dependency>