Application: gvSIG desktop » gvSIG legends: base legends

package org.gvsig.legend.urbanhorizontalsignage.swing.impl.convertlines;

import java.util.HashMap;

import java.util.Map;

import java.util.Properties;

import javax.swing.JComponent;

import javax.swing.event.TreeSelectionEvent;

import org.apache.commons.lang3.BooleanUtils;

import org.gvsig.fmap.dal.DataTypes;

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

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

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

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

import org.gvsig.fmap.dal.swing.DALSwingLocator;

import org.gvsig.fmap.dal.swing.DataSwingManager;

import org.gvsig.fmap.dal.swing.featuretype.AttributeDescriptorPickerController;

import org.gvsig.fmap.dal.swing.storesrepository.StoresRepositoryController;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.GeometryUtils;

import org.gvsig.legend.urbanhorizontalsignage.lib.api.linelegend.UrbanHorizontalSignageConfig;

import org.gvsig.legend.urbanhorizontalsignage.swing.api.ConvertLinesToPolygonsPanel;

import org.gvsig.tools.dispose.DisposeUtils;

import org.gvsig.tools.resourcesstorage.ResourcesStorage;

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

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

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

import org.gvsig.tools.swing.api.task.TaskStatusController;

import org.gvsig.tools.task.SimpleTaskStatus;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 *

 * @author gvSIG Team

 */

public class DefaultConvertLinesToPolygonsPanel 

        extends DefaultConvertLinesToPolygonsPanelView 

        implements ConvertLinesToPolygonsPanel 

    {

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

//    private static Map<String,Map<String,Object>> remindervalues = new HashMap<>();

    private AttributeDescriptorPickerController targetColorFieldController;

    private AttributeDescriptorPickerController targetLengthFieldController;

    private AttributeDescriptorPickerController targetAreaFieldController;

    private FeatureSet source;

    private UrbanHorizontalSignageConfig config;

    private TaskStatusController statusController;

    private StoresRepositoryController storesRepositoryController;

    public DefaultConvertLinesToPolygonsPanel() {

        this.source = null;

        initComponents();

    }

    private void initComponents(){

        ToolsSwingManager toolsSwingManager = ToolsSwingLocator.getToolsSwingManager();

        DataSwingManager dataSwingManager = DALSwingLocator.getDataSwingManager();

        targetColorFieldController = dataSwingManager.createAttributeDescriptorPickerController(cboTargetColorFields, (t) -> {

            return t.getDataType().isNumeric() || t.getType() == DataTypes.STRING;

        });

        targetColorFieldController.setEditable(true);

        targetLengthFieldController = dataSwingManager.createAttributeDescriptorPickerController(cboTargetLengthFields, (t) -> {

            return t.getDataType().isNumeric();

        });

        targetLengthFieldController.setEditable(true);

        targetAreaFieldController = dataSwingManager.createAttributeDescriptorPickerController(cboTargetAreaFields, (t) -> {

            return t.getDataType().isNumeric();

        });

        targetAreaFieldController.setEditable(true);

        this.treeTargetStore.getSelectionModel().addTreeSelectionListener((TreeSelectionEvent e) -> {

            doUpdateTargetFeatureType();

            updateEnableComponents();

        });

        this.storesRepositoryController = dataSwingManager.createStoresRepositoryController(treeTargetStore);

        this.statusController = ToolsSwingLocator.getTaskStatusSwingManager().createTaskStatusController(

                this.lblStatusCaption,

                this.lblStatusMsg,

                this.pbStatus

        );

        this.setTaskStatusVisible(false);

        translateAll();

        ToolsSwingUtils.ensureRowsCols(this, 13, 80, 20, 100);

        updateEnableComponents();

    }

    private void translateAll() {

        ToolsSwingManager toolsSwingmanager = ToolsSwingLocator.getToolsSwingManager();

        toolsSwingmanager.translate(this.lblTargetColorField);

        toolsSwingmanager.translate(this.lblTargetLengthField);

        toolsSwingmanager.translate(this.lblTargetAreaField);

        toolsSwingmanager.translate(this.lblElementsToProcess);

        toolsSwingmanager.translate(this.lblTargetLayer);

        toolsSwingmanager.translate(this.lblDeleteLinesAtFinish);

    }

    private void putFromResources(FeatureSet source) {

        FeatureStore store = null;

        ResourcesStorage resourcesStorage = null;

        ResourcesStorage.Resource resource = null;

        try {

            store = source.getFeatureStore();

            resourcesStorage = store.getResourcesStorage();

            resource = resourcesStorage.getResource("urbsignage_lines2pol");

            if( resource!=null ) {

                if( resource.exists() ) {

                    try {

                        Properties props = new Properties();

                        props.load(resource.asInputStream());

                        this.storesRepositoryController.setSelectedStore(props.getProperty("StoreName", null));

                        this.targetColorFieldController.set(props.getProperty("Color", null));

                        this.targetAreaFieldController.set(props.getProperty("Area", null));

                        this.targetLengthFieldController.set(props.getProperty("Len", null));

                        this.chkDeleteLinesAtFinish.setSelected(BooleanUtils.toBoolean(props.getProperty("DeleteAtFinish", "false")));

                    } catch (Exception ex) {

                        LOGGER.warn("Don't load values from resources for store "+store.getFullName(), ex);

                    }

                }

            }

        } finally {

            DisposeUtils.disposeQuietly(resource);

            DisposeUtils.disposeQuietly(resourcesStorage);

            DisposeUtils.disposeQuietly(store);

        }

    }

    private void saveValuesInResources(FeatureSet source) {

        FeatureStore store = null;

        ResourcesStorage resourcesStorage = null;

        ResourcesStorage.Resource resource = null;

        try {

            store = source.getFeatureStore();

            resourcesStorage = store.getResourcesStorage();

            resource = resourcesStorage.getResource("urbsignage_lines2pol");

            if( resource!=null ) {

                try {

                    String storeName = "";

                    store = this.storesRepositoryController.getSelectedFeatureStore();

                    if( store!=null ) {

                        storeName = store.getName();

                        DisposeUtils.dispose(store);

                    }

                    Properties props = new Properties();

                    props.setProperty("Color", this.targetColorFieldController.getName());

                    props.setProperty("Len", this.targetLengthFieldController.getName());

                    props.setProperty("Area", this.targetAreaFieldController.getName());

                    props.setProperty("DeleteAtFinish", BooleanUtils.toStringTrueFalse(this.chkDeleteLinesAtFinish.isSelected()));

                    props.setProperty("StoreName", storeName);

                    props.store(resource.asOutputStream(), "");

                    resource.close();

                } catch (Exception ex) {

                    LOGGER.warn("Don't save values to resources for store "+store.getFullName(), ex);

                }

            }

        } finally {

            DisposeUtils.disposeQuietly(resource);

            DisposeUtils.disposeQuietly(resourcesStorage);

            DisposeUtils.disposeQuietly(store);

        }

    }

    @Override

    public void setSource(FeatureSet source) {

        this.source = source;

        if( this.source==null || this.source.isEmpty() ) {

            this.targetColorFieldController.clean();

            this.targetAreaFieldController.clean();

            this.targetLengthFieldController.clean();

            this.txtElementsToProcess.setText("");

        } else {

            this.putFromResources(source);        

            this.txtElementsToProcess.setText(String.valueOf(this.source.size()));

        }

        this.updateEnableComponents();

    }

//    @Override

//    public void setStores(TreeModel stores) {

//        this.stores = stores;

//        this.treeTargetLayer.setModel(stores);

//        this.updateEnableComponents();

//    }

    @Override

    public UrbanHorizontalSignageConfig fetch(UrbanHorizontalSignageConfig config) {

        config.setTargetColorFieldName(this.targetColorFieldController.getName());

        config.setTargetLenghtFieldName(this.targetLengthFieldController.getName());

        config.setTargetAreaFieldName(this.targetAreaFieldController.getName());

//        saveValues();

        saveValuesInResources(this.source);

        return config;

    }

    @Override

    public void put(UrbanHorizontalSignageConfig config) {

        try {

            this.config = config.clone();

        } catch (CloneNotSupportedException ex) {

            throw new RuntimeException("Can't put config", ex);

        }

        if(config.getTargetColorFieldName()!=null){

            this.targetColorFieldController.set(config.getTargetColorFieldName());

        }

        if(config.getTargetLenghtFieldName()!=null){

            this.targetLengthFieldController.set(config.getTargetLenghtFieldName());

        }

        if(config.getTargetAreaFieldName()!=null){

            this.targetAreaFieldController.set(config.getTargetAreaFieldName());

        }

        this.updateEnableComponents();

    }

    @Override

    public JComponent asJComponent() {

        return this;

    }

    private void doUpdateTargetFeatureType() {

        FeatureType ft = this.getTargetFeatureType();

        if( ft == null ) {

            this.targetColorFieldController.clean();

            this.targetAreaFieldController.clean();

            this.targetLengthFieldController.clean();

            return;

        } 

        this.targetColorFieldController.setFeatureType(ft);

        this.targetAreaFieldController.setFeatureType(ft);

        this.targetLengthFieldController.setFeatureType(ft);

//        restoreValues();

    }

    private void updateEnableComponents() {

        if( this.source==null ) {

            this.targetColorFieldController.setEnabled(false);

            this.targetAreaFieldController.setEnabled(false);

            this.targetLengthFieldController.setEnabled(false);

            this.treeTargetStore.setEnabled(false);

            return;

        }

        this.treeTargetStore.setEnabled(true);

        if( this.getTargetStore()==null ) {

            this.targetColorFieldController.setEnabled(false);

            this.targetAreaFieldController.setEnabled(false);

            this.targetLengthFieldController.setEnabled(false);

            return;

        }

        this.targetColorFieldController.setEnabled(true);

        this.targetAreaFieldController.setEnabled(true);

        this.targetLengthFieldController.setEnabled(true);

    }

    @Override

    public UrbanHorizontalSignageConfig getConfig() {

        return this.fetch(this.config);

    }

    @Override

    public FeatureSet getSource() {

        return this.source;

    }

    @Override

    public FeatureStore getTargetStore() {

        FeatureStore store = this.storesRepositoryController.getSelectedFeatureStore();

        if( store == null ) {

            return null;

        }

        try {

            FeatureType ft = store.getDefaultFeatureTypeQuietly();

            FeatureAttributeDescriptor geomattr = ft.getDefaultGeometryAttribute();

            int geomtype = geomattr.getGeomType().getType();

            if( GeometryUtils.isSubtype(Geometry.TYPES.POLYGON, geomtype) ||

                GeometryUtils.isSubtype(Geometry.TYPES.MULTIPOLYGON, geomtype) ) {

                return store;

            }

            return null;

        } catch(Exception ex) {

            LOGGER.warn("Can't get target store",ex);

            return null;

        }

    }

    private FeatureType getTargetFeatureType() {

        FeatureStore store = this.getTargetStore();

        if( store == null) {

            return null;

        }

        return store.getDefaultFeatureTypeQuietly();

    }

    @Override

    public SimpleTaskStatus getTaskStatus() {

        return this.statusController.getSimpleTaskStatus();

    }

    @Override

    public void setTaskStatusVisible(boolean visible) {

        this.pbStatus.setVisible(visible);

        this.lblStatusCaption.setVisible(visible);

        this.lblStatusMsg.setVisible(visible);

    }

    @Override

    public boolean getDeleteSourceAtFinish() {

        return this.chkDeleteLinesAtFinish.isSelected();

    }

    @Override

    public void setDeleteSourceAtFinish(boolean deleteSourceAtFinish) {

        this.chkDeleteLinesAtFinish.setSelected(deleteSourceAtFinish);

    }

//    private void restoreValues() {

//        FeatureStore store = this.getTargetStore();

//        if( store!=null ) {

//            Map<String,Object> values = remindervalues.get(store.getFullName());

//            if( values!=null ) {

//                this.targetColorFieldController.set((String) values.get("Color"));

//                this.targetAreaFieldController.set((String) values.get("Area"));

//                this.targetLengthFieldController.set((String) values.get("Len"));

//                this.chkDeleteLinesAtFinish.setSelected((boolean) values.get("DeleteAtFinish"));

//                LOGGER.info("Restore values for store "+store.getFullName());

//            } else {

//                LOGGER.info("Don't locate values for store "+store.getFullName());

//            }

//        }

//    }

//    

//    private void saveValues() {

//        FeatureStore targetStore = this.getTargetStore();

//        if( targetStore!=null ) {

//            Map<String,Object>values = new HashMap<>();

//            values.put("Color", this.targetColorFieldController.getName());

//            values.put("Len", this.targetLengthFieldController.getName());

//            values.put("Area", this.targetAreaFieldController.getName());

//            values.put("DeleteAtFinish", this.chkDeleteLinesAtFinish.isSelected());

//            remindervalues.put(targetStore.getFullName(),values);

//            LOGGER.info("Save values for store "+targetStore.getFullName());

//        }

//        

//    }

}