Application: gvSIG desktop » gvSIG legends: base legends

package org.gvsig.legend.urbanhorizontalsignage.app;

import java.io.File;

import java.util.UUID;

import javax.swing.JOptionPane;

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.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.DataStoreParameters;

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

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

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

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

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

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

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

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

import org.gvsig.fmap.dal.store.jdbc.JDBCNewStoreParameters;

import org.gvsig.fmap.dal.store.jdbc.JDBCServerExplorer;

import org.gvsig.fmap.dal.store.jdbc.JDBCServerExplorerParameters;

import org.gvsig.fmap.geom.DataTypes;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.aggregate.MultiPolygon;

import org.gvsig.fmap.mapcontext.MapContext;

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

import org.gvsig.legend.urbanhorizontalsignage.lib.api.UrbanHorizontalSignageData;

import static org.gvsig.legend.urbanhorizontalsignage.lib.api.UrbanHorizontalSignageData.CONTINUITY_MODE_CONT_DISC;

import static org.gvsig.legend.urbanhorizontalsignage.lib.api.UrbanHorizontalSignageData.CONTINUITY_MODE_DISC;

import static org.gvsig.legend.urbanhorizontalsignage.lib.api.UrbanHorizontalSignageData.CONTINUITY_MODE_DISC_CONT;

import static org.gvsig.legend.urbanhorizontalsignage.lib.api.UrbanHorizontalSignageData.CONTINUITY_MODE_DISC_DISC;

import org.gvsig.legend.urbanhorizontalsignage.lib.api.UrbanHorizontalSignageLegend;

import org.gvsig.legend.urbanhorizontalsignage.lib.api.UrbanHorizontalSignageLocator;

import org.gvsig.legend.urbanhorizontalsignage.lib.api.UrbanHorizontalSignageManager;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dispose.DisposeUtils;

import org.gvsig.tools.folders.FoldersManager;

import org.gvsig.tools.i18n.I18nManager;

import org.gvsig.tools.util.HasAFile;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

public class UrbanHorizontalSignageExtension extends Extension {

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

    @Override

    public void initialize() {

        IconThemeHelper.registerIcon("legend", "legend-overview-vectorial-urbanhorizontalsignage", this);

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

    }

    @Override

    public void execute(String actionCommand) {

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

            return;

        }

        DataManager dataManager = DALLocator.getDataManager();

        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;

        }

        UrbanHorizontalSignageManager uhsManager = UrbanHorizontalSignageLocator.getUrbanHorizontalSignageManager();

        UrbanHorizontalSignageLegend legend = (UrbanHorizontalSignageLegend) layer.getLegend();

        EditableFeatureType targetFeatureType = createTargetFeatureType(layer.getFeatureStore());

        FeatureStore targetStore = createTemporalStore(targetFeatureType);

        FeatureSet featureSet = null;

        try {

            targetStore.edit(FeatureStore.MODE_APPEND);

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

            for (Feature feature : selection) {

                Geometry originalGeometry = feature.getDefaultGeometry();

                UrbanHorizontalSignageData data = legend.getValues(feature);

                uhsManager.calculateGeometries(originalGeometry, data);

                MultiPolygon multiGeom = data.getSegmentsGeometry();

                if (multiGeom != null && multiGeom.getPrimitivesNumber() > 0) {

                    for (Geometry geometry : multiGeom) {

                        EditableFeature targetFeature = targetStore.createNewFeature();

                        targetFeature.copyFrom(feature, (FeatureAttributeDescriptor t) -> !(t.isPrimaryKey() || (t.isIndexed() && !t.allowIndexDuplicateds()) || t.getType() == DataTypes.GEOMETRY));

                        targetFeature.setDefaultGeometry(geometry);

                        targetStore.insert(targetFeature);

                    }

                }

                switch (data.getContinuity()) {

                    case CONTINUITY_MODE_CONT_DISC:

                    case CONTINUITY_MODE_DISC_CONT:

                    case CONTINUITY_MODE_DISC:

                    case CONTINUITY_MODE_DISC_DISC:

                        if (data.isPaintHoles()) {

                            multiGeom = data.getHolesGeometry();

                            if (multiGeom != null && multiGeom.getPrimitivesNumber() > 0) {

                                for (Geometry geometry : multiGeom) {

                                    EditableFeature targetFeature = targetStore.createNewFeature();

                                    targetFeature.copyFrom(feature, (FeatureAttributeDescriptor t) -> !(t.isPrimaryKey() || (t.isIndexed() && !t.allowIndexDuplicateds()) || t.getType() == DataTypes.GEOMETRY));

                                    targetFeature.setDefaultGeometry(geometry);

                                    targetStore.insert(targetFeature);

                                }

                            }

                        }

                }

            }

            targetStore.finishEditing();

            featureSet = targetStore.getFeatureSet();

            I18nManager i18n = ToolsLocator.getI18nManager();

            int n = application.confirmDialog(

                    "_Number_of_geometries_to_be_copied_to_the_clipboard" + " " + featureSet.getSize() + "\n" + "_Do_you_want_to_continue",

                    i18n.getTranslation("_Copy_selected_features_as_polygons_to_clipboard"),

                    JOptionPane.YES_NO_OPTION,

                    JOptionPane.QUESTION_MESSAGE);

            if (n == JOptionPane.YES_OPTION) {

                dataManager.putFeaturesInClipboard(featureSet);

            }

        } catch (Exception e) {

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

        } finally {

            DisposeUtils.disposeQuietly(targetStore);

            DisposeUtils.disposeQuietly(featureSet);

        }

    }

    private EditableFeatureType createTargetFeatureType(FeatureStore store) {

        DataManager dataManager = DALLocator.getDataManager();

        EditableFeatureType featureType = dataManager.createFeatureType();

        featureType.addAll(store.getDefaultFeatureTypeQuietly());

        EditableFeatureAttributeDescriptor attr = (EditableFeatureAttributeDescriptor) featureType.getDefaultGeometryAttribute();

        attr.setGeometryType(Geometry.TYPES.POLYGON, Geometry.SUBTYPES.GEOM2D);

        return featureType;

    }

    private FeatureStore createTemporalStore(EditableFeatureType featType) {

        if (featType.getStore() != null) {

            throw new IllegalArgumentException("Can't create temporal store from a feature type of a already existent store.");

        }

        try {

            // crear ruta de archivo temporal

            FoldersManager foldersManager = ToolsLocator.getFoldersManager();

            File tempFile = foldersManager.getUniqueTemporaryFile("urbanHorizontalSignage_temporal_store_" + UUID.randomUUID().toString());

            // crear SERVER STORE

            DataManager dataManager = DALLocator.getDataManager();

            JDBCServerExplorerParameters serverParameters = (JDBCServerExplorerParameters) dataManager.createServerExplorerParameters("H2Spatial");

            ((HasAFile) serverParameters).setFile(tempFile);

            JDBCServerExplorer serverExplorer = (JDBCServerExplorer) dataManager.openServerExplorer("H2Spatial", serverParameters);

            //Crear tablas en server store

            JDBCNewStoreParameters parametersResults = serverExplorer.getAddParameters();

            parametersResults.setDynValue("Table", "results");

            parametersResults.setDefaultFeatureType(featType);

            serverExplorer.add("H2Spatial", parametersResults, true);

            DataStoreParameters storeParametersResults = dataManager.createStoreParameters("H2Spatial");

            storeParametersResults.setDynValue("database_file", tempFile);

            storeParametersResults.setDynValue("Table", "results");

            //Creaci?n del store con los resultados

            FeatureStore storeResults = (FeatureStore) dataManager.openStore("H2Spatial", storeParametersResults);

            return storeResults;

        } catch (Exception ex) {

            LOGGER.debug("Can't create temporal store.", ex);

            return null;

        }

    }

    @Override

    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 {

            FeatureStore store = layer.getFeatureStore();

            FeatureSelection selection = store.getFeatureSelection();

            if (selection.isEmpty()) {

                return false;

            }

            return (layer.getLegend() instanceof UrbanHorizontalSignageLegend);

//            return !selection.isEmpty();

        } catch (Exception ex) {

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

            return false;

        }

    }

    @Override

    public boolean isVisible() {

        ApplicationManager application = ApplicationLocator.getManager();

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

    }

}