Application: gvSIG desktop » gvSIG legends: base legends

package org.gvsig.legend.picturemarkersymboltable.swing.impl;

import java.awt.event.ActionEvent;

import java.awt.event.ItemEvent;

import java.util.ArrayList;

import java.util.Collections;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import javax.swing.ComboBoxModel;

import javax.swing.DefaultComboBoxModel;

import javax.swing.ImageIcon;

import javax.swing.JPanel;

import org.apache.commons.collections4.CollectionUtils;

import org.apache.commons.lang.StringUtils;

import org.gvsig.app.project.documents.view.legend.gui.Categories;

import org.gvsig.expressionevaluator.ExpressionUtils;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.DataStoreParameters;

import org.gvsig.fmap.dal.DataTypes;

import org.gvsig.fmap.dal.StoresRepository;

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

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

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

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

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.geom.Geometry;

import org.gvsig.fmap.geom.GeometryUtils;

import org.gvsig.fmap.mapcontext.MapContext;

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

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

import org.gvsig.fmap.mapcontext.rendering.legend.ILegend;

import org.gvsig.legend.picturemarkersymboltable.lib.api.PictureMarkerSymbolTableLegend;

import static org.gvsig.legend.picturemarkersymboltable.lib.api.PictureMarkerSymbolTableLegend.DEFAULT_IMAGE_SIZE;

import org.gvsig.legend.picturemarkersymboltable.lib.api.PictureMarkerSymbolTableLocator;

import org.gvsig.legend.picturemarkersymboltable.swing.api.PictureMarkerSymbolTableLegendEditor;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dispose.DisposeUtils;

import org.gvsig.tools.i18n.I18nManager;

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

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.documentfilters.DoubleDocumentFilter;

import org.gvsig.tools.swing.api.pickercontroller.ColorPickerController;

import org.gvsig.tools.swing.icontheme.IconTheme;

import org.gvsig.tools.util.LabeledValue;

import org.gvsig.tools.util.LabeledValueImpl;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

@SuppressWarnings("UseSpecificCatch")

public class DefaultPictureMarkerSymbolTableLegendEditor extends DefaultPictureMarkerSymbolTableLegendEditorView implements PictureMarkerSymbolTableLegendEditor {

    private static final long serialVersionUID = 4307714097793669675L;

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

    private PictureMarkerSymbolTableLegend legend;

    private FLayer layer;

    private final Class<? extends PictureMarkerSymbolTableLegend> legendClass;

    private ColorPickerController pickerLineToOffsetColor;

    private AttributeDescriptorPickerController pickerClassifyingField;

    private AttributeDescriptorPickerController pickerOffsetXField;

    private AttributeDescriptorPickerController pickerOffsetYField;

    private AttributeDescriptorPickerController pickerRotationField;

    private AttributeDescriptorPickerController pickerLineToOffsetColorField;

    private AttributeDescriptorPickerController pickerImagesTableClassifyingField;

    private AttributeDescriptorPickerController pickerImageField;

    private AttributeDescriptorPickerController pickerImageSelectedField;

    private List<String> availablesTables;

    public DefaultPictureMarkerSymbolTableLegendEditor() {

        this.legendClass = PictureMarkerSymbolTableLocator

                .getPictureMarkerSymbolTableManager()

                .getPictureMarkerSymbolTableLegendClass();

        initComponents();

    }

    private void initComponents(){

        ToolsSwingManager toolsSwingManager = ToolsSwingLocator.getToolsSwingManager();

        DataSwingManager dataSwingManager = DALSwingLocator.getDataSwingManager();

        translateAll();

        DoubleDocumentFilter.install(this.txtImageSize);

        this.cboUnits.setModel(this.createModelUnits());

        this.cboUnits.setSelectedIndex(0);

        this.pickerLineToOffsetColor = toolsSwingManager.createColorPickerController(this.txtLineToOffsetColor, this.btnLineToOffsetColor);

        this.pickerClassifyingField = dataSwingManager.createAttributeDescriptorPickerController(cboClassifyingFieldName, (t) -> {

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

        });

        this.pickerOffsetXField = dataSwingManager.createAttributeDescriptorPickerController(cboOffsetXFieldName, (t) -> {

            return t.getDataType().isNumeric();

        });

        this.pickerOffsetYField = dataSwingManager.createAttributeDescriptorPickerController(cboOffsetYFieldName, (t) -> {

            return t.getDataType().isNumeric();

        });

        this.pickerRotationField = dataSwingManager.createAttributeDescriptorPickerController(cboRotationFieldName, (t) -> {

            return t.getDataType().isNumeric();

        });

        this.pickerLineToOffsetColorField = dataSwingManager.createAttributeDescriptorPickerController(cboLineToOffsetColorFieldName, (t) -> {

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

        });

        this.cboImagesTableName.setModel(this.createImagesTableNameModel());        

        this.pickerImagesTableClassifyingField = dataSwingManager.createAttributeDescriptorPickerController(cboImagesTableClassifyingFieldName, (t) -> {

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

        });

        this.pickerImageField = dataSwingManager.createAttributeDescriptorPickerController(cboImageFieldName, (t) -> {

            return StringUtils.equalsIgnoreCase("Image", t.getDataProfileName());

        });

        this.pickerImageSelectedField = dataSwingManager.createAttributeDescriptorPickerController(cboImageSelectedFieldName, (t) -> {

            return StringUtils.equalsIgnoreCase("Image", t.getDataProfileName());

        });

        this.cboImagesTableName.addItemListener((ItemEvent e) -> {

            doChangeImageTableName();

        });

        this.btnImagesTableNameRefresh.addActionListener((ActionEvent e) -> {

            doRefreshImageTables();

        });

        this.cboImagesTableName.setSelectedIndex(-1);

        DoubleDocumentFilter.install(this.txtScale);

    }

    private void translateAll() {

        ToolsSwingManager toolsSwingmanager = ToolsSwingLocator.getToolsSwingManager();

        toolsSwingmanager.translate(this.lblClassifyingFieldName);

        toolsSwingmanager.translate(this.lblDrawLineToOffset);

        toolsSwingmanager.translate(this.lblImageFieldName);

        toolsSwingmanager.translate(this.lblImageSelectedFieldName);

        toolsSwingmanager.translate(this.lblImagesTableClassifyingFieldName);

        toolsSwingmanager.translate(this.lblImagesTableFields);

        toolsSwingmanager.translate(this.lblImagesTableName);

        toolsSwingmanager.translate(this.lblLegendTableFields);

        toolsSwingmanager.translate(this.lblLineToOffsetColor);

        toolsSwingmanager.translate(this.lblLineToOffsetColorFieldName);

        toolsSwingmanager.translate(this.lblOffsetXFieldName);

        toolsSwingmanager.translate(this.lblOffsetYFieldName);

        toolsSwingmanager.translate(this.lblRotationFieldName);

        toolsSwingmanager.translate(this.lblImageSize);

        toolsSwingmanager.translate(this.lblUnits);

        toolsSwingmanager.translate(this.lblScale);

        toolsSwingmanager.translate(this.lblReverseDirectionOfAngle);

    }

    private ComboBoxModel createModelUnits() {

        I18nManager i18n = ToolsLocator.getI18nManager();

        DefaultComboBoxModel<LabeledValue<Integer>> model = new DefaultComboBoxModel<>();

        model.addElement(new LabeledValueImpl<>(i18n.getTranslation("_Pixels"),-1));

        String[] names=MapContext.getDistanceNames();

        int n = 0;

        for (String name : names) {

            model.addElement(new LabeledValueImpl<>(i18n.getTranslation(name),n++));

        }

        return model;

    }

    @Override

    public void setData(FLayer layer, ILegend legend) {

        if( layer == this.layer && legend == this.legend ) {

            return;

        }

        this.layer = layer;

        if( this.getLegendClass().isInstance(legend) ) {

            this.legend = (PictureMarkerSymbolTableLegend) legend;

        } else {

            this.legend = PictureMarkerSymbolTableLocator

                    .getPictureMarkerSymbolTableManager()

                    .createPictureMarkerSymbolTableLegend();

        }

        if( layer instanceof FLyrVect ) {

            FeatureStore store = ((FLyrVect) layer).getFeatureStore();

            if( store != null ) {

                try {

                    FeatureType ftype = store.getDefaultFeatureType();

                    this.txtImageSize.setText(String.valueOf(this.legend.getImageSize()));

                    ListElement.setSelected(this.cboUnits, this.legend.getUnits());

                    this.pickerLineToOffsetColor.set(this.legend.getDefaultLineToOffsetColor());

                    this.chkDrawLineToOffset.setSelected(this.legend.isDrawLineToOffset());

                    this.chkReverseDirectionOfAngle.setSelected(this.legend.isReverseDirectionOfAngle());

                    this.pickerClassifyingField.setFeatureType(ftype);

                    this.pickerOffsetXField.setFeatureType(ftype);

                    this.pickerOffsetYField.setFeatureType(ftype);

                    this.pickerRotationField.setFeatureType(ftype);

                    this.pickerLineToOffsetColorField.setFeatureType(ftype);

                    ListElement.setSelected(this.cboImagesTableName, this.legend.getImagesTableName());

                    this.pickerClassifyingField.set(this.legend.getClassifyingFieldName());

                    this.pickerLineToOffsetColorField.set(this.legend.getLineToOffsetColorFieldName());

                    this.pickerRotationField.set(this.legend.getRotationFieldName());

                    this.pickerOffsetXField.set(this.legend.getOffsetXFieldName());

                    this.pickerOffsetYField.set(this.legend.getOffsetYFieldName());

                    DoubleDocumentFilter.setValue(this.txtScale, this.legend.getScale());

                } catch (Exception ex) {

                    LOGGER.warn("Can't fill data of legend.", ex);

                    //FIXME: ?hacemos algo m?s con la excepci?n?

                }

            }

        }

    }

    @Override

    public ILegend getLegend() {

        this.legend.setImageSize(this.getImageSize());

        this.legend.setUnits((int) ListElement.getSelected(this.cboUnits));

        this.legend.setDefaultLineToOffsetColor(this.pickerLineToOffsetColor.get());

        this.legend.setDrawLineToOffset(this.chkDrawLineToOffset.isSelected());

        this.legend.setReverseDirectionOfAngle(this.chkReverseDirectionOfAngle.isSelected());

        this.legend.setClassifyingFieldName(this.pickerClassifyingField.getName());

        this.legend.setOffsetXFieldName(this.pickerOffsetXField.getName());

        this.legend.setOffsetYFieldName(this.pickerOffsetYField.getName());

        this.legend.setRotationFieldName(this.pickerRotationField.getName());

        this.legend.setLineToOffsetColorFieldName(this.pickerLineToOffsetColorField.getName());

        this.legend.setImagesTableName((String) this.cboImagesTableName.getSelectedItem());

        this.legend.setImagesTableClassifyingFieldName(this.pickerImagesTableClassifyingField.getName());

        this.legend.setImageFieldName(this.pickerImageField.getName());

        this.legend.setImageSelectedFieldName(this.pickerImageSelectedField.getName());

        this.legend.setScale(DoubleDocumentFilter.getValue(this.txtScale));

        return legend;

    }

    private int getImageSize() {

        String s = this.txtImageSize.getText();

        return ExpressionUtils.parseInt(null, s, DEFAULT_IMAGE_SIZE);

    }

    @Override

    public String getDescription() {

        I18nManager i18n = ToolsLocator.getI18nManager();

        return i18n.getTranslation( "_Picture_marker_symbol_table_legend");

    }

    @Override

    public ImageIcon getIcon() {

        IconTheme theme = ToolsSwingLocator.getIconThemeManager().getCurrent();

        return theme.get("legend-overview-vectorial-picturemarkersymboltable");

    }

    @Override

        public Class getParentClass() {

                return Categories.class;

        }

    @Override

    public String getTitle() {

        I18nManager i18n = ToolsLocator.getI18nManager();

        return i18n.getTranslation( "_Picture_marker_symbol_table_legend");

    }

    @Override

    public JPanel getPanel() {

        return this;

    }

    @Override

    public Class getLegendClass() {

        return this.legendClass;

    }

    @Override

    public boolean isSuitableFor(FLayer layer) {

        if(layer instanceof FLyrVect){

            return true;

//            try {

//                int shapeType = ((FLyrVect)layer).getShapeType();

//                return GeometryUtils.isSubtype(Geometry.TYPES.POINT, shapeType);

//            } catch (Exception ex) {

//                LOGGER.debug("Can't get shape type for layer "+layer.getName(), ex);

//                return false;

//            }

        }

        return false;

    }

    public void doChangeImageTableName() {

        String tableName = (String) this.cboImagesTableName.getSelectedItem();

        if( StringUtils.isNotBlank(tableName) ) {

            FeatureStore store = null;

            try {

                DataManager dataManager = DALLocator.getDataManager();

                StoresRepository repositories = dataManager.getStoresRepository();

                store = (FeatureStore) repositories.getStore(tableName);

                FeatureType ftype = store.getDefaultFeatureTypeQuietly();

                boolean hasimages = false;

                for (FeatureAttributeDescriptor attr : ftype) {

                    if( StringUtils.equalsIgnoreCase("Image", attr.getDataProfileName()) ) {

                        hasimages = true;

                        break;

                    } 

                }

                if( hasimages ) {

                    this.pickerImagesTableClassifyingField.setFeatureType(ftype);

                    this.pickerImageField.setFeatureType(ftype);

                    this.pickerImageSelectedField.setFeatureType(ftype);

                    this.pickerImagesTableClassifyingField.setEnabled(true);

                    this.pickerImageField.setEnabled(true);

                    this.pickerImageSelectedField.setEnabled(true);    

                    this.pickerImagesTableClassifyingField.set(this.legend.getImagesTableClassifyingFieldName());

                    this.pickerImageField.set(this.legend.getImageFieldName());

                    this.pickerImageSelectedField.set(this.legend.getImageSelectedFieldName());

                    return;

                }

            } catch(Exception ex) {

                LOGGER.debug("Can't use '"+tableName+"' as table for retrieve images.",ex);

                // Do nothing

            } finally {

                DisposeUtils.disposeQuietly(store);

            }

        }

        this.pickerImagesTableClassifyingField.clean();

        this.pickerImageField.clean();

        this.pickerImageSelectedField.clean();

        this.pickerImagesTableClassifyingField.setEnabled(false);

        this.pickerImageField.setEnabled(false);

        this.pickerImageSelectedField.setEnabled(false);

    }

    private void createListOfAvailableTables() {

        DataManager dataManager = DALLocator.getDataManager();

        Map<String,Integer> allTableNames = new HashMap<>();

        StoresRepository repositories = dataManager.getStoresRepository();

        for (String tableName : repositories.keySet()) {

            DataStoreParameters params = repositories.get(tableName);

            if( params instanceof OpenFeatureStoreParameters ) {

                if( allTableNames.containsKey(tableName) ) {

                    allTableNames.put(tableName, allTableNames.get(tableName)+1);

                } else {

                    allTableNames.put(tableName, 1);

                }

            }

        }

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

        for (String tableName : allTableNames.keySet()) {

            if( allTableNames.get(tableName)==1 ) {

                tableNames.add(tableName);

            }

        }

        Collections.sort(tableNames);

        this.availablesTables = tableNames;

    }

    private ComboBoxModel createImagesTableNameModel() {

        if( CollectionUtils.isEmpty(this.availablesTables) ) {

            createListOfAvailableTables();

        }

        DefaultComboBoxModel<String> model = new DefaultComboBoxModel<>();

        for (String tableName : availablesTables) {

            model.addElement(tableName);

        }

        return model;

    }

    private void doRefreshImageTables() {

        availablesTables = null;

        cboImagesTableName.setModel(createImagesTableNameModel());        

        cboImagesTableName.setSelectedIndex(-1);

    }

    @Override

    public ImageIcon loadImage(String imageName) {

        return ToolsSwingUtils.loadImage(this, imageName);

    }

}