gvSIG projects pool

package org.gvsig.vcsgis.app.addlayer;

import java.util.ArrayList;

import java.util.Comparator;

import java.util.List;

import java.util.function.Function;

import javax.swing.JOptionPane;

import javax.swing.SwingUtilities;

import org.apache.commons.lang.StringUtils;

import org.cresques.cts.IProjection;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.DataStoreParameters;

import org.gvsig.fmap.dal.StoresRepository;

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

import org.gvsig.fmap.dal.store.db.DBStoreParameters;

import org.gvsig.fmap.geom.Geometry;

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

import org.gvsig.fmap.mapcontext.BaseCreateLayerParameters;

import org.gvsig.fmap.mapcontext.MapContext;

import org.gvsig.fmap.mapcontext.MapContextLocator;

import org.gvsig.fmap.mapcontext.MapContextManager;

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

import org.gvsig.fmap.mapcontrol.MapControl;

import org.gvsig.geodb.TableInfo;

import static org.gvsig.geodb.vectorialdb.visibility.LayerScaleVisibilityUtils.checkForVisibilityScale;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.i18n.I18nManager;

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

import org.gvsig.tools.swing.api.threadsafedialogs.ThreadSafeDialogsManager;

import org.gvsig.tools.task.SimpleTaskStatus;

import static org.gvsig.vcsgis.app.addlayer.AbstractWizardVCSGis.LOGGER;

import org.gvsig.vcsgis.lib.VCSGisEntity;

import org.gvsig.vcsgis.lib.workspace.VCSGisWorkspace;

/**

 *

 * @author gvSIG Team

 */

@SuppressWarnings("UseSpecificCatch")

public class WizardVCSGisVectorial extends AbstractWizardVCSGis {

    @SuppressWarnings("OverridableMethodCallInConstructor")

    public WizardVCSGisVectorial() {

        super();

        this.setVisibleMaintainStructureInToC(true);

    }

    @Override

    protected boolean requireGeometry() {

        return true;

    }

    @Override

    public Object executeWizard() {

        DataManager man = DALLocator.getDataManager();

        MapContextManager mapContextManager = MapContextLocator.getMapContextManager();

        MapControl mapControl = this.getMapCtrl();

        MapContext mapContext = mapControl.getMapContext();

        LayersWithGroup layers = new LayersWithGroup(mapContext);

        VCSGisWorkspace workspace = this.getWorkspace();

        boolean checkScale = this.getCheckScale();

        boolean addToCWhenLoadingAll = this.getAddToCWhenLoadingAll();

        for (TableInfo tableInfo : getTablesInformation()) {

            if (!tableInfo.isSelected()) {

                continue;

            }

            if( ((VCSGisTableInfo)tableInfo).needConnectToModel() ) {

                I18nManager i18n = ToolsLocator.getI18nManager();

                ThreadSafeDialogsManager dialogs = ToolsSwingLocator.getThreadSafeDialogsManager();

                int n = dialogs.confirmDialog(

                        i18n.getTranslation("_Some_of_the_selected_tables_require_connection_to_a_data_model") + 

                                "\n" +

                                i18n.getTranslation("_It_is_recommended_that_you_connect_to_the_data_model_before_loading_the_tables") +

                                "\n" +

                                i18n.getTranslation("_Do_you_want_to_add_the_selected_tables_anyway"), 

                        i18n.getTranslation("_AddLayer"), 

                        JOptionPane.YES_NO_OPTION, 

                        JOptionPane.QUESTION_MESSAGE, 

                        "_Some_of_the_selected_tables_require_connection_to_a_data_model"

                );

                if( n != JOptionPane.YES_OPTION ) {

                    return null;

                }

            }

        }

        Thread th = new Thread(() -> {

            SimpleTaskStatus taskstatus = ToolsLocator.getTaskStatusManager().createDefaultSimpleTaskStatus("Loading layers");        

            taskstatus.setIndeterminate();

            taskstatus.setAutoremove(true);

            taskstatus.add();

            try {

                List<VCSGisTableInfo> tablesInformation = new ArrayList<>();

                for (TableInfo tableInfo : getTablesInformation()) {

                    if (!tableInfo.isSelected()) {

                        continue;

                    }

                    tablesInformation.add((VCSGisTableInfo) tableInfo);

                }

                tablesInformation.sort(new Comparator<VCSGisTableInfo>() {

                    @Override

                    public int compare(VCSGisTableInfo o1, VCSGisTableInfo o2) {

                        if( o1==null || o2==null ) {

                            return 0;

                        }

                        VCSGisEntity e1 = o1.getEntity();

                        VCSGisEntity e2 = o2.getEntity();

                        if( e1==null || e2==null ) {

                            return 0;

                        }

                        FeatureType ft1 = o1.getFeatureType();

                        FeatureType ft2 = o2.getFeatureType();

                        int order1 = (ft1==null)? 0:ft1.getTags().getInt("TOC_Order",0);

                        int order2 = (ft2==null)? 0:ft2.getTags().getInt("TOC_Order",0);

                        String id1 = String.format("%05d/%02d/%s/%s", order1, getLayerOrderWeight(e1), getCategory(e1), e1.getLabelOrName());

                        String id2 = String.format("%05d/%02d/%s/%s", order2, getLayerOrderWeight(e2), getCategory(e2), e2.getLabelOrName());

                        return id2.compareTo(id1);

                    }

                });

                List<String> dataModels = new ArrayList<>();

                for (VCSGisTableInfo tableInfo : tablesInformation) {

                    VCSGisEntity entity = tableInfo.getEntity();

                    List<String> entityModels = entity.getDataModelsAsList();

                    if( entityModels!=null ) {

                        for (String entityModel : entityModels) {

                            dataModels.add(entityModel);

                        }

                    }

                }

                if( !dataModels.isEmpty() ) {

                    for (StoresRepository storesRepository : man.getStoresRepository().getSubrepositories() ) {

                        dataModels.remove(storesRepository.getID());

                    }

                    for (String dataModel : dataModels) {

                        registerDataModelRepository(workspace, dataModel);

                    }

                }

                taskstatus.setRangeOfValues(0, tablesInformation.size());

                FLayer layer;

                for (VCSGisTableInfo tableInfo : tablesInformation) {

                    if( taskstatus.isCancellationRequested() ) {

                        taskstatus.cancel();

                        return;

                    }

                    taskstatus.message(tableInfo.getEntity().getLabelOrName());

                    LOGGER.info("Load layer '"+tableInfo.getId()+"'");

                    DBStoreParameters params = tableInfo.getParameters();

                    VCSGisEntity entity = tableInfo.getEntity();

                    List<String> entityModels = entity.getDataModelsAsList();

                    if( entityModels!=null ) {

                        for (String entityModel : entityModels) {

                            dataModels.add(entityModel);

                        }

                    }

                    String category = this.getCategory(entity);

                    fixCRS(params);

                    if( tableInfo.getVisible()==null ) {

                        tableInfo.setVisible(entity.getCategoryTags(category).getBoolean("visibility", true));

                    }

                    boolean defaultVisibility = tableInfo.getVisible();

//                    FeatureStore store;

//                    try {

//                        store = (FeatureStore) man.openStore(

//                                params.getDataStoreName(),

//                                params

//                        );

//                    } catch (Exception e) {

//                        LOGGER.warn("While opening DB store.", e);

//                        taskstatus.abort();

//                        return;

//                    }

                    try {

                        layer = mapContextManager.createLayer(

                                tableInfo.getDocumentName(), 

                                new BaseCreateLayerParameters(params, defaultVisibility)

                        );

//                        layer = mapContextManager.createLayer(

//                                tableInfo.getDocumentName(),

//                                store

//                        );

                        if( defaultVisibility ) {

                            checkForVisibilityScale(layer, checkScale);

                        }

                        String tableName = params.getTable();

                        if (StringUtils.isBlank(tableName)) {

                            layers.add(null, null, layer);

                        } else {

                            if (workspace.getWorkspaceEntityByName(tableName) == null) {

                                layers.add(null, tableName, layer);

                            } else {

                                layers.add(category, layer.getName(), layer);

                            }

                        }

                        if( !addToCWhenLoadingAll ) {

                            SwingUtilities.invokeLater(() -> {

                                layers.updateMapControl(mapControl, maintainStructureInToC(), LayersWithGroup.UPDATE_MODE_SKIP_DUPLICATES);

                            });

                        }

                    } catch (Exception e) {

                        LOGGER.warn("Can't create layer '" + tableInfo.getDocumentName() + "'.", e);

                    } finally {

//                        DisposeUtils.disposeQuietly(store);

                    }

                    taskstatus.incrementCurrentValue();

                }

                if( addToCWhenLoadingAll ) {

                    SwingUtilities.invokeLater(() -> {

                        layers.updateMapControl(mapControl, maintainStructureInToC(), false);

                        layers.disposeLayers();

                    });

                } else {

                    SwingUtilities.invokeLater(() -> {

                        layers.disposeLayers();

                    });

                }

                taskstatus.terminate();

            } finally {

                // Dispose all created layers. If they have been included into

                // a FLayers object, they will have been binded there.

//                for (FLayer layer : layers) {

//                    layer.dispose();

//                }

            }

        }, "WizardVCSGisVectorial");

        this.startTask(th);

        return null;

    }

    private void fireLayerErrorEvent(FLayer lyr, MapControl mapControl) {

        mapControl.getMapContext().callNewErrorEvent(null);

    }

    @Override

    protected Function<VCSGisEntity, String> getLabelEntityFormatter() { 

        return (VCSGisEntity entity) -> {

            String label = this.getWorkspace().formatEntityLabel(entity);

            FeatureType type = entity.getFeatureType();

            if (type == null) {

                return label;

            }

            IProjection srs = type.getDefaultSRS();

            if (srs == null) {

                return label;

            }

            MapContext mapContext1 = getMapContext();

            if (mapContext1 == null) {

                return label + " [" + srs.getAbrev() + "]";

            }

            if (mapContext1.getProjection() == null) {

                return label + " [" + srs.getAbrev() + "]";

            }

            if (StringUtils.equalsIgnoreCase(mapContext1.getProjection().getAbrev(), srs.getAbrev())) {

                return label + " [" + srs.getAbrev() + "]";

            }

            return label + " [" + srs.getAbrev() + "!]";

        };

    }

    private int getLayerOrderWeight(VCSGisEntity entity) {

        int type2d = Geometry.TYPES.SURFACE;

        try {

            GeometryType geomtype = entity.getFeatureType().getDefaultGeometryAttribute().getGeomType();

            type2d = simplifyType(geomtype);

        } catch (Exception e) {

            LOGGER.warn("While getting geo type.", e);

        }

        switch (type2d) {

            case Geometry.TYPES.SURFACE:

                return 2;

            case Geometry.TYPES.CURVE:

                return 1;

            case Geometry.TYPES.POINT:

                return 0;

            default:

                // should not reach this

                return 3;

        }

    }

    private int simplifyType(GeometryType gt) {

        if (gt.isTypeOf(Geometry.TYPES.POINT) || gt.isTypeOf(Geometry.TYPES.MULTIPOINT)) {

            return Geometry.TYPES.POINT;

        } else if (gt.isTypeOf(Geometry.TYPES.CURVE) || gt.isTypeOf(Geometry.TYPES.MULTICURVE)) {

            return Geometry.TYPES.CURVE;

        } else if (gt.isTypeOf(Geometry.TYPES.SURFACE) || gt.isTypeOf(Geometry.TYPES.MULTISURFACE)) {

            return Geometry.TYPES.SURFACE;

        }

        return Geometry.TYPES.SURFACE;

    }

}