Application: gvSIG desktop

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright (C) 2007-2013 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 3

 * 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.app.extension.clipboard;

import java.io.StringReader;

import java.util.ArrayList;

import java.util.List;

import java.util.function.Predicate;

import javax.swing.JOptionPane;

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

import org.apache.commons.lang3.StringUtils;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.gvsig.andami.IconThemeHelper;

import org.gvsig.andami.plugins.Extension;

import org.gvsig.app.ApplicationLocator;

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.dal.feature.EditableFeature;

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

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.GeometryUtils;

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

import org.gvsig.fmap.mapcontext.MapContext;

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

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

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.i18n.I18nManager;

import org.gvsig.tools.logger.FilteredLogger;

import javax.json.JsonObject;

import javax.json.Json;

import javax.json.JsonArray;

import javax.json.JsonReader;

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

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

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

public class PasteFeaturesFromClipboardExtension extends Extension {

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

    @Override

    public void initialize() {

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

    }

    @Override

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

        FeatureType ft = store.getDefaultFeatureTypeQuietly();

        boolean hasPk = false;

        if( !jsonArray.isEmpty() ) {

            JsonObject fjson0 = (JsonObject) jsonArray.get(0);

            for (String name : fjson0.keySet()) {

                FeatureAttributeDescriptor attr = ft.getAttributeDescriptor(name);

                if( attr!=null ) {

                    if( attr.isPrimaryKey() ) {

                        hasPk = true;

                        break;

                    }

                }

            }

        }

        final boolean copyPk;

        if( hasPk ) {

            int n = application.confirmDialog(

                    i18n.getTranslation("_Copy_primary_key_values_XQuestionX"),

                    i18n.getTranslation("_Pasting_features_from_clipboard"),

                    JOptionPane.YES_NO_OPTION,

                    JOptionPane.QUESTION_MESSAGE, 

                    "_CopyPrimaryKeyWhenPasteFeaturesFromClipboard"

            );

            copyPk = ( n == JOptionPane.YES_OPTION );

        } else {

            copyPk = false;

        }

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

                f.copyFrom(fjson, new Predicate<FeatureAttributeDescriptor>() {

                    @Override

                    public boolean test(FeatureAttributeDescriptor attr) {

                        if( !copyPk && attr.isPrimaryKey() ) {

                            return false;

                        }

                        return true;

                    }

                });

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

        }

    }

    @Override

    public boolean isEnabled() {

        ApplicationManager application = ApplicationLocator.getManager();

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

        if( viewdoc == null ) {

            return false;

        }

        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;

    }

    @Override

    public boolean isVisible() {

        ApplicationManager application = ApplicationLocator.getManager();

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

    }

}