Application: gvSIG desktop

/*

 * To change this license header, choose License Headers in Project Properties.

 * To change this template file, choose Tools | Templates

 * and open the template in the editor.

 */

package org.gvsig.app.extension.geometriespalette;

import java.awt.Component;

import java.awt.Dimension;

import java.awt.Graphics2D;

import java.awt.Image;

import java.awt.image.BufferedImage;

import java.util.AbstractList;

import java.util.ArrayList;

import java.util.Collections;

import java.util.List;

import javax.swing.AbstractListModel;

import javax.swing.DefaultListCellRenderer;

import javax.swing.ImageIcon;

import javax.swing.JComponent;

import javax.swing.JLabel;

import javax.swing.JList;

import javax.swing.SpinnerNumberModel;

import javax.swing.SwingConstants;

import javax.swing.event.ChangeEvent;

import javax.swing.event.ListSelectionEvent;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.expressionevaluator.Expression;

import org.gvsig.expressionevaluator.ExpressionUtils;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

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

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.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.featuretype.FeatureAttributeListCellRenderer;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.GeometryUtils;

import org.gvsig.fmap.geom.primitive.Envelope;

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

import org.gvsig.fmap.mapcontext.ViewPort;

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

import org.gvsig.fmap.mapcontext.rendering.symbols.ISymbol;

import org.gvsig.symbology.fmap.mapcontext.rendering.symbol.fill.impl.SimpleFillSymbol;

import org.gvsig.symbology.fmap.mapcontext.rendering.symbol.line.impl.SimpleLineSymbol;

import org.gvsig.symbology.fmap.mapcontext.rendering.symbol.marker.impl.SimpleMarkerSymbol;

import org.gvsig.tools.dispose.DisposeUtils;

import org.gvsig.tools.dynobject.Tags;

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

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.windowmanager.WindowManager;

import org.gvsig.tools.util.LabeledValue;

import org.gvsig.tools.util.LabeledValueImpl;

/**

 *

 * @author gvSIG Team

 */

public class GeometriesPalettePanel extends GeometriesPalettePanelView implements org.gvsig.tools.swing.api.Component {

    private AttributeDescriptorPickerController labelPicker;

    private FeatureAttributeDescriptor attributeLabel;

    private ISymbol symbol;

    private FeatureAttributeDescriptor geomattr;

    private FeatureStore store;

    private FilteredListController dataController;

    private AttributeDescriptorPickerController colorPicker;

    private AttributeDescriptorPickerController groupPicker;

    private Expression filter;

    private class FeratureWithGeomCellRenderer extends DefaultListCellRenderer {

        @Override

        public Component getListCellRendererComponent(

                JList<?> list,

                Object value,

                int index,

                boolean isSelected,

                boolean cellHasFocus) {

            JLabel label = (JLabel) super.getListCellRendererComponent(list, value, index, isSelected, cellHasFocus);

            try {

                LabeledValue<List<Feature>> x = (LabeledValue<List<Feature>>) value;

                if ( x!=null && x.getValue() != null && symbol!=null ) {

                    Image img = drawGeometry(x.getValue());

                    label.setHorizontalAlignment(SwingConstants.CENTER);

                    label.setHorizontalTextPosition(JLabel.CENTER);

                    label.setVerticalTextPosition(JLabel.BOTTOM);

                    label.setIcon(new ImageIcon(img));

                    if( StringUtils.isBlank(x.getLabel()) ) {

                        label.setText("(Configure label)");

                    } else {

                        label.setText(x.getLabel());

                    }

                }

            } catch(Throwable th) {

                label.setText("Error");

            }

            return label;

        }

    }

    public GeometriesPalettePanel() {

        initComponents();

    }

    private void initComponents() {

        ToolsSwingManager toolsSwingManager = ToolsSwingLocator.getToolsSwingManager();

        DataSwingManager dataSwingManager = DALSwingLocator.getDataSwingManager();

        FeatureAttributeListCellRenderer renderer = dataSwingManager.createDefaultFeatureAttributeListCellRenderer();

        renderer.setUseLabels(DataManager.USE_LABELS_NO);

        this.cboLabel.setRenderer(renderer);

        labelPicker = dataSwingManager.createAttributeDescriptorPickerController(this.cboLabel);

        labelPicker.addChangeListener((ChangeEvent e) -> {

            doChangeAttrLabel();

        });

        renderer = dataSwingManager.createDefaultFeatureAttributeListCellRenderer();

        renderer.setUseLabels(DataManager.USE_LABELS_NO);

        this.cboColor.setRenderer(renderer);

        colorPicker = dataSwingManager.createAttributeDescriptorPickerController(this.cboColor);

        colorPicker.addChangeListener((ChangeEvent e) -> {

            doChangeAttrColor();

        });

        colorPicker.setAllowNull(true);

        renderer = dataSwingManager.createDefaultFeatureAttributeListCellRenderer();

        renderer.setUseLabels(DataManager.USE_LABELS_NO);

        this.cboGroup.setRenderer(renderer);

        groupPicker = dataSwingManager.createAttributeDescriptorPickerController(this.cboGroup);

        groupPicker.addChangeListener((ChangeEvent e) -> {

            doChangeAttrGroup();

        });

        groupPicker.setAllowNull(true);

        SpinnerNumberModel spnSizeModel = new SpinnerNumberModel(100, 30, 600, 10);

        this.spnSize.setModel(spnSizeModel);

        this.spnSize.addChangeListener((ChangeEvent e) -> { doChangeSize(); });

        this.lstData.setCellRenderer(new FeratureWithGeomCellRenderer());

        this.lstData.addListSelectionListener((ListSelectionEvent e) -> {

            if( e.getValueIsAdjusting() ) {

                return;

            }

            doCopyFeature();

        });

        this.dataController = toolsSwingManager.createFilteredListController(lstData, txtDataFilter, btnDataFilter);

        colorPicker.setEnabled(false);

        groupPicker.setEnabled(false);

        ToolsSwingUtils.ensureRowsCols(this, 25,40,25,80);

    }

    private void doChangeSize() {

        this.lstData.updateUI();

    }

    private void doChangeAttrGroup() {

    }

    private void doChangeAttrColor() {

    }

    private void doCopyFeature() {

        try {

            LabeledValue<List<Feature>> x = (LabeledValue<List<Feature>>) this.lstData.getSelectedValue();

            if( x == null ) {

                return;

            }

            DataManager dataManager = DALLocator.getDataManager();

            FeatureSelection selection = this.store.createFeatureSelection();

            for (Feature feature : x.getValue()) {

                selection.select(feature);

            }

            dataManager.putFeaturesInClipboard(selection);

        } catch (DataException ex) {

            // TODO: LOGGER.warn

        }

    }

    private Image drawGeometry(List<Feature> features) {

        int pixels = (int) this.spnSize.getValue();

        Dimension size = new Dimension(pixels, pixels);

        BufferedImage img = new BufferedImage(size.width, size.height, BufferedImage.TYPE_INT_ARGB);

        ViewPort viewPort = new ViewPort();

        viewPort.setImageSize(size);

        viewPort.setProjection(geomattr.getSRS());

        if( features.size()==1 ) {

            Geometry geom = (Geometry) features.get(0).get(geomattr.getName());

            viewPort.setEnvelope(geom.getEnvelope());

        } else {

            Envelope envelope = GeometryUtils.createEnvelope(Geometry.SUBTYPES.GEOM2D);

            for (Feature feature : features) {

                Geometry geom = (Geometry) feature.get(geomattr.getName());

                envelope.add(geom);

            }

            viewPort.setEnvelope(envelope);

        }

        for (Feature feature : features) {

            Geometry geom = (Geometry) feature.get(geomattr.getName());

            this.symbol.draw(

                    (Graphics2D) img.getGraphics(), 

                    viewPort.getAffineTransform(),

                    geom,

                    feature, 

                    null

            );

        }

        return img;

    }

    private static class DataModel extends AbstractListModel<LabeledValue<List<Feature>>> {

        private List<LabeledValue<List<Feature>>> elements;

        private FeatureAttributeDescriptor attributeLabel;

        public DataModel() {

            this.elements = Collections.EMPTY_LIST;

        }

        public DataModel(FeatureAttributeDescriptor attributeLabel) {

            this();

            this.attributeLabel = attributeLabel;

        }

        public DataModel(FeatureStore store, Expression filter, FeatureAttributeDescriptor attributeLabel, FeatureAttributeDescriptor attributeGroup) {

            this(attributeLabel);

            String groupAttributeName = attributeGroup.getName();

            String order = groupAttributeName;

            if( attributeLabel!=null ) {

                order = order+","+attributeLabel.getName();

            }

            LabeledValueImpl<List<Feature>> element = null;

            String previousGroup = null;

            FeatureSet features = createFeatureSet(store, filter, order);

            for (Feature feature : features) {

                if( !StringUtils.equals(previousGroup, feature.getString(groupAttributeName)) ) {

                    if( element != null ) {

                        elements.add(element);

                    }

                    element = new LabeledValueImpl<>(

                            feature.getString(attributeLabel.getName()),

                            new ArrayList<>()

                    );

                }

                element.getValue().add(feature.getCopy());

            }

            DisposeUtils.disposeQuietly(features);

        }

        public DataModel(FeatureStore store, Expression filter, FeatureAttributeDescriptor attributeLabel) {

            this(attributeLabel);

            String order = null;

            if( attributeLabel != null ) {

                order = attributeLabel.getName();

            }

            List<Feature> features = store.getFeatures(filter, order);

            this.elements = new AbstractList<LabeledValue<List<Feature>>> () {

                @Override

                public LabeledValue<List<Feature>> get(int index) {

                    Feature feature = features.get(index);

                    String label = "";

                    if( attributeLabel!=null ) {

                        label = feature.getLabelOfValue(attributeLabel.getName());

                    }

                    return new LabeledValueImpl(label,Collections.singletonList(feature));

                }

                @Override

                public int size() {

                    return features.size();

                }

            };

        }

        @Override

        public int getSize() {

            return this.elements.size();

        }

        @Override

        public LabeledValue<List<Feature>> getElementAt(int index) {

            LabeledValue<List<Feature>> element = this.elements.get(index);

            return element;

        }

    }

    private void doChangeAttrLabel() {

        this.attributeLabel = this.labelPicker.get();

        this.lstData.setModel(new DataModel(store, filter, attributeLabel));

    }

    public void setFilter(String filter) {

        this.filter = ExpressionUtils.createExpression(filter);

    }

    public void setFilter(Expression filter) {

        this.filter = filter;

    }

    public void setFeatureStore(FeatureStore store) {

        this.store = store;

        FeatureType featureType = store.getDefaultFeatureTypeQuietly();

        this.lstData.setModel(new DataModel());

        this.labelPicker.setFeatureType(featureType);

        this.colorPicker.setFeatureType(featureType);

        this.groupPicker.setFeatureType(featureType);

        this.geomattr = featureType.getDefaultGeometryAttribute();

        GeometryType geomtype = geomattr.getGeomType();

        if( GeometryUtils.isSubtype(Geometry.TYPES.POINT, geomtype.getType()) ||

                GeometryUtils.isSubtype(Geometry.TYPES.MULTIPOINT, geomtype.getType())) {

            this.symbol = new SimpleMarkerSymbol();

        } else if( GeometryUtils.isSubtype(Geometry.TYPES.SURFACE, geomtype.getType()) ||

                GeometryUtils.isSubtype(Geometry.TYPES.MULTISURFACE, geomtype.getType())) {

            this.symbol = new SimpleFillSymbol();

        } else if( GeometryUtils.isSubtype(Geometry.TYPES.CURVE, geomtype.getType()) ||

                GeometryUtils.isSubtype(Geometry.TYPES.MULTICURVE, geomtype.getType())) {

            this.symbol = new SimpleLineSymbol();

        }

    }

    public void updateListContents() {

        FeatureAttributeDescriptor groupAttribute = this.groupPicker.get();

        if( groupAttribute == null ) {

            this.lstData.setModel(new DataModel(store, filter, attributeLabel));

        } else {

            this.lstData.setModel(new DataModel(store, filter, attributeLabel, groupAttribute));

        }

    }

    public static void showPalette(FLyrVect layer) {

        showPalette(layer.getFeatureStore(), null, null, null);

    }

    public static void showPalette(FeatureStore store, String labelattr, String title, String filter) {

        final WindowManager windowManager = ToolsSwingLocator.getWindowManager();

        FeatureType featureType = store.getDefaultFeatureTypeQuietly();

        Tags tags = featureType.getTags();

        if( StringUtils.isBlank(title) ) {

            title = tags.getString("geometriespalette.title", "");

        }

        if( StringUtils.isBlank(filter) ) {

            title = tags.getString("geometriespalette.filter", null);

        }

        if( StringUtils.isBlank(labelattr) ) {

            labelattr = tags.getString("geometriespalette.attribute.label", null);

        }

        String attrGroup = tags.getString("geometriespalette.attribute.group", null);

        String attrColor = tags.getString("geometriespalette.attribute.color", null);

        int size = tags.getInt("geometriespalette.size",-1);

        GeometriesPalettePanel palette = new GeometriesPalettePanel();

        palette.setFilter(filter);

        palette.setFeatureStore((FeatureStore) store);

        palette.setGroupAttributeName(attrGroup);

        palette.setColorAttributeName(attrColor);

        if( size>0 ) {

            palette.setSize(size);

        }

        if( StringUtils.isNotBlank(labelattr) ) {

            palette.setLabelAttributeName(labelattr);

        }

        if( StringUtils.isBlank(title) ) {

            title = ToolsSwingUtils.makeTitle("Palette",store.getName(),null);

        }

        windowManager.showWindow(

                palette.asJComponent(),

                title,

                WindowManager.MODE.TOOL

        );

    }

    void setLabelAttributeName(String labelattr) {

        this.labelPicker.set(labelattr);

    }

    void setGroupAttributeName(String attrGroup) {

        this.groupPicker.set(attrGroup);

    }

    void setColorAttributeName(String attrColor) {

        this.colorPicker.set(attrColor);

    }

    public void setSize(int size) {

        this.spnSize.setValue(size);

    }

    private static FeatureSet createFeatureSet(FeatureStore store, Expression filter, String groupAttributeName) {

        try {

            FeatureSet features = store.getFeatureSet(filter, groupAttributeName);

            return features;

        } catch (DataException ex) {

            throw new RuntimeException("Can't create feature set", ex);

        }

    }

    @Override

    public JComponent asJComponent() {

        if( this.lstData.getModel().getSize()==0 ) {

            updateListContents();

        }

        return this;

    }

}