Application: gvSIG desktop

package org.gvsig.geodb;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.List;

import java.util.Map;

import javax.swing.JComponent;

import javax.swing.SwingUtilities;

import org.apache.commons.codec.binary.Hex;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.andami.PluginServices;

import org.gvsig.andami.PluginsLocator;

import org.gvsig.andami.PluginsManager;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.DataStore;

import org.gvsig.fmap.dal.DataStoreParameters;

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

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

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

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

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

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

import org.gvsig.fmap.mapcontext.MapContext;

import org.gvsig.fmap.mapcontext.MapContextLocator;

import org.gvsig.fmap.mapcontext.MapContextManager;

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

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

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

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

import org.gvsig.fmap.mapcontrol.MapControl;

import static org.gvsig.geodb.AbstractWizardDB.LOGGER;

import org.gvsig.geodb.vectorialdb.visibility.VisibilityScaleSelector;

import org.gvsig.geodb.vectorialdb.visibility.LayerScaleVisibility;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DynObject;

import org.gvsig.tools.i18n.I18nManager;

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

import org.gvsig.tools.swing.api.windowmanager.WindowManager;

/**

 *

 * @author jjdelcerro

 */

public class WizardDBVectorial extends AbstractWizardDB {

    public static final int NUMBER_OF_FEATURES_TO_ASK_FOR_VISIBILITY_SCALE = 500;

    public static final String LAYERS_SCALE_VISIBILITY_PARAMETER="layersScaleVisibility";

    public WizardDBVectorial() {

        super();

    }

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

        String groupName = null;

        List<FLayer> all_layers = new ArrayList();

        try {

            FLayer layer = null;

            for (TableInfo tableInfo : this.getTablesInformation()) {

                if (!tableInfo.isSelected()) {

                    continue;

                }

                DBStoreParameters parameter = tableInfo.getParameters();

                if (groupName == null) {

                    String dbname = parameter.getDBName();

                    if (StringUtils.isEmpty(dbname)) {

                        dbname = "Group";

                    }

                    String host = parameter.getHost();

                    if (StringUtils.isEmpty(host)) {

                        groupName = dbname;

                    } else {

                        groupName = dbname + " (" + host + ")";

                    }

                }

                FeatureStore store;

                try {

                    store = (FeatureStore) man.openStore(

                            parameter.getDataStoreName(),

                            parameter);

                } catch (Exception e) {

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

                    return null;

                }

                try {

                    layer = mapContextManager.createLayer(

                            tableInfo.getDocumentName(),

                            store

                    );

                    checkForVisibilityScale(layer);

                    all_layers.add(layer);

                } catch (Exception e) {

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

                }

            }

            if (all_layers.size() > 1) {

                FLayers group = new FLayers();

                group.setMapContext(mapContext);

                group.setParentLayer(mapContext.getLayers());

                group.setName(groupName);

                for (FLayer aLayer : all_layers) {

                    group.addLayer(aLayer);

                }

                if ( group.isOk() ) {

                    group.setVisible(true);

                    mapContext.beginAtomicEvent();

                    try {

                        mapControl.addLayer(group);

                        group.dispose();

                    } catch (CancelationException e) {

                        LOGGER.warn("Can't add group to mapcontext layers.", e);

                    } finally {

                        mapContext.endAtomicEvent();

                    }

                } else {

                    fireLayerErrorEvent(layer, mapControl);

                }

            } else if (all_layers.size() == 1) {

                layer = (FLayer) all_layers.get(0);

                if ( layer.isOk() ) {

                    layer.setVisible(true);

                    mapContext.beginAtomicEvent();

                    try {

                        mapControl.addLayer(layer);

                    } catch (CancelationException e) {

                        LOGGER.warn("Can't add group to mapcontext layers.", e);

                    } finally {

                        mapContext.endAtomicEvent();

                    }

                } else {

                    fireLayerErrorEvent(layer, mapControl);

                }

            }

        } finally {

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

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

            for (FLayer layer : all_layers) {

                layer.dispose();

            }

        }

        return null;

    }

    private void fireLayerErrorEvent(FLayer lyr, MapControl mapControl) {

        mapControl.getMapContext().callNewErrorEvent(null);

    }

        private void checkForVisibilityScale(FLayer layer) throws DataException, ValidateDataParametersException {

        PluginsManager pluginManager = PluginsLocator.getPluginsManager();

        PluginServices plugin = pluginManager.getPlugin(ExtDB_Spatial.class);

        DynObject pluginProperties = plugin.getPluginProperties();

        Map<String, LayerScaleVisibility> layersScaleVisibility = (Map) pluginProperties.getDynValue(LAYERS_SCALE_VISIBILITY_PARAMETER);

        String layerKey = buildLayerKey(layer);

        if(layerKey != null) {

            LayerScaleVisibility layerScaleVisibility = layersScaleVisibility.get(layerKey);

            if(layerScaleVisibility!=null){

                int scaleAboveDenominator = layerScaleVisibility.getScaleAboveDenominator();

                int scaleBelowDenominator = layerScaleVisibility.getScaleBelowDenominator();

                layer.setMaxScale(scaleAboveDenominator);

                layer.setMinScale(scaleBelowDenominator);

                return;

            }

        }

        if (layer instanceof FLyrVect) {

            FLyrVect lyrVect = (FLyrVect)layer;

            FeatureStore store = lyrVect.getFeatureStore();

            if((store.getExplorer() instanceof JDBCServerExplorer)

                    && (store.getFeatures().size()>NUMBER_OF_FEATURES_TO_ASK_FOR_VISIBILITY_SCALE) ){

                askUserForVisibilityScale(layer);

            }

        }

    }

    private void askUserForVisibilityScale(FLayer layer) {

        if (!SwingUtilities.isEventDispatchThread()) {

            SwingUtilities.invokeLater(new Runnable() {

                @Override

                public void run() {

                    askUserForVisibilityScale(layer);

                }

            });

            return;

        }

        VisibilityScaleSelector visibilityScaleSelector = new VisibilityScaleSelector();

        I18nManager i18nManager = ToolsLocator.getI18nManager();

        WindowManager winManager = ToolsSwingLocator.getWindowManager();

        winManager.showWindow(

                (JComponent) visibilityScaleSelector, 

                i18nManager.getTranslation("select_visibility_scale"), 

                WindowManager.MODE.DIALOG

        );

        if (visibilityScaleSelector.isOkPressed()) {

            layer.setMaxScale(visibilityScaleSelector.getScaleAboveDenominator());

            layer.setMinScale(visibilityScaleSelector.getScaleBelowDenominator());

            if(visibilityScaleSelector.getRememberAnswer()){

                PluginsManager pluginManager = PluginsLocator.getPluginsManager();

                PluginServices plugin = pluginManager.getPlugin(ExtDB_Spatial.class);

                DynObject pluginProperties = plugin.getPluginProperties();

                String layerKey = buildLayerKey(layer);

                String layerLabel = buildLayerLabel(layer);

                if(layerKey != null && layerLabel != null){

                    Map<String, LayerScaleVisibility> layersScaleVisibility = (Map) pluginProperties.getDynValue(LAYERS_SCALE_VISIBILITY_PARAMETER);

                    LayerScaleVisibility layerScaleVisibility = new LayerScaleVisibility();

                    layerScaleVisibility.setScaleAboveDenominator(visibilityScaleSelector.getScaleAboveDenominator());

                    layerScaleVisibility.setScaleBelowDenominator(visibilityScaleSelector.getScaleBelowDenominator());

                    layerScaleVisibility.setLabel(layerLabel);

                    layersScaleVisibility.put(layerKey, layerScaleVisibility);

                }

            }

        }

    }

    private String buildLayerKey(FLayer layer) {

        if(layer!=null){

            DataStore dataStore = ((FLyrVect)layer).getDataStore();

            if(dataStore != null){

                DataStoreParameters parameters = dataStore.getParameters();

                if(parameters != null){

                    return Arrays.toString(Hex.encodeHex(parameters.toByteArray()));

                }

            }

        }

        return null;

    }

    private String buildLayerLabel(FLayer layer) {

        if(layer!=null){

            DataStore dataStore = ((FLyrVect)layer).getDataStore();

            if(dataStore != null){

                    StringBuilder builder = new StringBuilder();

                    DataStoreParameters parameters = dataStore.getParameters();

                    if(parameters != null && parameters instanceof DBStoreParameters){

                        JDBCStoreParameters jdbcParameters = (JDBCStoreParameters)parameters;

                        builder.append(jdbcParameters.getDBName());

                        builder.append(".");

                        builder.append(jdbcParameters.getSchema());

                        builder.append(".");

                        builder.append(jdbcParameters.getTable());

                        return builder.toString();

                }

            }

        }

        return null;

    }

}