Application: gvSIG desktop » gvSIG legends: base legends

/* gvSIG. Sistema de Informaci?n Geogr?fica de la Generalitat Valenciana

 *

 * Copyright (C) 2005 IVER T.I. and Generalitat Valenciana.

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 2

 * of the License, or (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307,USA.

 *

 * For more information, contact:

 *

 *  Generalitat Valenciana

 *   Conselleria d'Infraestructures i Transport

 *   Av. Blasco Ib??ez, 50

 *   46010 VALENCIA

 *   SPAIN

 *

 *      +34 963862235

 *   gvsig@gva.es

 *      www.gvsig.gva.es

 *

 *    or

 *

 *   IVER T.I. S.A

 *   Salamanca 50

 *   46005 Valencia

 *   Spain

 *

 *   +34 963163400

 *   dac@iver.es

 */

package org.gvsig.symbology.gui.layerproperties;

import java.awt.BorderLayout;

import java.awt.Color;

import java.awt.Dimension;

import java.awt.FlowLayout;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import javax.swing.BorderFactory;

import javax.swing.DefaultComboBoxModel;

import javax.swing.ImageIcon;

import javax.swing.JComboBox;

import javax.swing.JLabel;

import javax.swing.JOptionPane;

import javax.swing.JPanel;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.gvsig.andami.IconThemeHelper;

import org.gvsig.app.ApplicationLocator;

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

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

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

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

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

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

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

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryManager;

import org.gvsig.fmap.mapcontext.MapContextLocator;

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

import org.gvsig.fmap.mapcontext.layers.operations.ClassifiableVectorial;

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

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

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

import org.gvsig.gui.beans.swing.GridBagLayoutPanel;

import org.gvsig.gui.beans.swing.JBlank;

import org.gvsig.gui.beans.swing.JNumberSpinner;

import org.gvsig.i18n.Messages;

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

import org.gvsig.symbology.fmap.mapcontext.rendering.symbol.line.ILineSymbol;

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

import org.gvsig.symbology.fmap.mapcontext.rendering.symbol.marker.IMarkerSymbol;

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

import org.gvsig.symbology.fmap.mapcontext.rendering.symbol.style.IMarkerFillPropertiesStyle;

import org.gvsig.symbology.fmap.rendering.ProportionalSymbolsLegend;

import org.gvsig.tools.dispose.DisposableIterator;

/**

 * Implements the panel for the legend of proportional symbols.In the interface

 * will be options to select the value field, the normalization field (if the

 * user wants to use it) and options to select the symbol an its minimum and

 * maximum size.

 *

 * Also there will be possible to select a background symbol (only when the

 * shapetype of the layer is polygonal).

 *

 * @author jaume dominguez faus - jaume.dominguez@iver.es

 * @author jldominguez

 */

public class ProportionalSymbolsPanel extends JPanel implements ILegendPanel {

    private static Logger logger = LoggerFactory.getLogger(ProportionalSymbolsPanel.class);

    private static final long serialVersionUID = 7394720230276170902L;

    private JPanel symbolPanel;

    private JPanel backgroundPanel;

    private JSymbolPreviewButton tmplateSymbol;

    private JSymbolPreviewButton backSymbol;

    private JComboBox cmbValue;

    private JComboBox cmbNormalization;

    private JNumberSpinner txtMinSize;

    private JNumberSpinner txtMaxSize;

    private ClassifiableVectorial myLayer;

    private ProportionalSymbolsLegend auxLegend;

    private String[] fieldNames;

    private int templateShapeType = 0;

    private String noNormalization = Messages.getText("none");

    private boolean useNormalization = true;

    /**

     * Default constructor

     */

    public ProportionalSymbolsPanel() {

        initialize();

    }

    /**

     * This method initializes this

     */

    private void initialize() {

        setLayout(new BorderLayout());

        JPanel aux = new JPanel(new BorderLayout());

        JPanel fieldsPanel = new JPanel(new FlowLayout());

        fieldsPanel.setBorder(BorderFactory.

                createTitledBorder(null,

                        Messages.getText("fields")

                ));

        fieldsPanel.setPreferredSize(new Dimension(300, 60));

        cmbValue = new JComboBox();

        cmbValue.setActionCommand("VALUE_SELECTED");

        cmbNormalization = new JComboBox();

        cmbNormalization.setActionCommand("NORMALIZATION_SELECTED");

        fieldsPanel.add(new JLabel(

                Messages.getText("value")

                + ":"));

        fieldsPanel.add(cmbValue);

        fieldsPanel.add(new JLabel(

                Messages.getText("normalization")

                + ":"));

        fieldsPanel.add(cmbNormalization);

        symbolPanel = new JPanel(new FlowLayout(FlowLayout.LEADING, 3, 2));

        symbolPanel.setBorder(BorderFactory.

                createTitledBorder(null,

                        Messages.getText("symbol")

                ));

        GridBagLayoutPanel aux2 = new GridBagLayoutPanel();

        aux2.addComponent(new JLabel(

                Messages.getText("size")

        ));

        aux2.addComponent(new JBlank(10, 10));

        aux2.addComponent(

                Messages.getText("from")

                + ":",

                getTxtMinSize());

        aux2.addComponent(

                Messages.getText("to")

                + ":",

                getTxtMaxSize());

        JPanel templatePanel = new JPanel();

        templatePanel.setBorder(BorderFactory.createTitledBorder(null,

                Messages.getText("template")

        ));

        templatePanel.add(getTemplSymbol());

        symbolPanel.add(new JBlank(10, 10));

        symbolPanel.add(aux2);

        symbolPanel.add(new JBlank(10, 10));

        symbolPanel.add(templatePanel);

        aux.add(fieldsPanel, BorderLayout.NORTH);

        aux.add(symbolPanel, BorderLayout.CENTER);

        this.add(aux, BorderLayout.CENTER);

        cmbValue.addActionListener(action);

        cmbNormalization.addActionListener(action);

        tmplateSymbol.addActionListener(action);

    }

    /**

     * Creates the panel where the button for the background symbol will be

     * placed

     *

     * @return JPanel panel

     */

    private JPanel getBackgroundPanel() {

        backgroundPanel = new JPanel();

        backgroundPanel.setBorder(BorderFactory.createTitledBorder(null,

                Messages.getText("background")

        ));

        backgroundPanel.add(getBtnBackground());

        return backgroundPanel;

    }

    /**

     * Creates a JNumberSpinner which is used to select the maximum size for the

     * symbol

     *

     * @return JNumberSpinner

     */

    private JNumberSpinner getTxtMaxSize() {

        if (txtMaxSize == null) {

            txtMaxSize = new JNumberSpinner(25.0, 7, 0.0, 100.0, 1.0, 2);

            txtMaxSize.addActionListener(action);

        }

        return txtMaxSize;

    }

    /**

     * Creates a JNumberSpinner which is used to select the minimum size for the

     * symbol

     *

     * @return JNumberSpinner

     */

    private JNumberSpinner getTxtMinSize() {

        if (txtMinSize == null) {

            txtMinSize = new JNumberSpinner(3.0, 7, 0.0, 100.0, 1.0, 2);

            txtMinSize.addActionListener(action);

        }

        return txtMinSize;

    }

    /**

     * Creates a JSymbolPreviewButton which is used to select the template

     * symbol

     *

     * @return JSymbolPreviewButton

     */

    private JSymbolPreviewButton getTemplSymbol() {

        if (tmplateSymbol == null) {

            int tst = ProportionalSymbolsLegend.isPolygonal(this.templateShapeType)

                    ? Geometry.TYPES.POINT

                    : this.templateShapeType;

            tmplateSymbol = new JSymbolPreviewButton(tst);

        }

        tmplateSymbol.setPreferredSize(new Dimension(100, 45));

        return tmplateSymbol;

    }

    /**

     * Creates a JSymbolPreviewButton which is used to select the background

     * symbol

     *

     * @return JSymbolPreviewButton

     */

    private JSymbolPreviewButton getBtnBackground() {

        if (backSymbol == null) {

            backSymbol = new JSymbolPreviewButton(Geometry.TYPES.SURFACE);

            backSymbol.setPreferredSize(new Dimension(100, 45));

            ISymbol fillsym = MapContextLocator.getSymbolManager().createSymbol(

                    Geometry.TYPES.SURFACE, Color.ORANGE);

            backSymbol.setSymbol(fillsym);

        }

        return backSymbol;

    }

    /**

     * Creates a new symbol of an specific shapetype with a concrete size

     *

     * @param shapeType

     * @param size

     *

     * @return ISymbol symbol created

     */

    private ISymbol newSymbol(int shapeType, double size) {

        if (getTemplSymbol().getSymbol() == null) {

            ISymbol templateSymbol;

            GeometryManager geomManager = GeometryLocator.getGeometryManager();

            if (geomManager.isSubtype(Geometry.TYPES.POINT, shapeType)

                    || geomManager.isSubtype(Geometry.TYPES.MULTIPOINT, shapeType)

                    || geomManager.isSubtype(Geometry.TYPES.SURFACE, shapeType)

                    || geomManager.isSubtype(Geometry.TYPES.MULTISURFACE, shapeType)) {

                templateSymbol = new SimpleMarkerSymbol();

                ((SimpleMarkerSymbol) templateSymbol).setSize(size);

                ((SimpleMarkerSymbol) templateSymbol).setColor(Color.DARK_GRAY);

            } else if (geomManager.isSubtype(Geometry.TYPES.CURVE, shapeType)

                    || geomManager.isSubtype(Geometry.TYPES.MULTICURVE, shapeType)) {

                templateSymbol = new SimpleLineSymbol();

                ((SimpleLineSymbol) templateSymbol).setLineWidth(size);

                ((SimpleLineSymbol) templateSymbol).setLineColor(Color.DARK_GRAY);

            } else {

                throw new RuntimeException("Unknown symbol type");

            }

            getTemplSymbol().setSymbol(templateSymbol);

            return newSymbol(shapeType, size);

        } else {

            // clone symbol

            ISymbol mySymbol = getTemplSymbol().getSymbol();

            try {

                mySymbol = (ISymbol) mySymbol.clone();

            } catch (CloneNotSupportedException e) {

                logger.info("Error while cloning symbol", e);

                ApplicationLocator.getManager().messageDialog(

                        Messages.getText("_Unable_to_clone_symbol"),

                        Messages.getText("error"),

                        JOptionPane.ERROR_MESSAGE);

            }

            if (mySymbol instanceof ILineSymbol) {

                ILineSymbol lSym = (ILineSymbol) mySymbol;

                lSym.setLineWidth(size);

            }

            if (mySymbol instanceof IMarkerSymbol) {

                IMarkerSymbol mSym = (IMarkerSymbol) mySymbol;

                mSym.setSize(size);

                if (ProportionalSymbolsLegend.isPolygonal(shapeType)) {

                    // this is to allow using in Polygon layers

                    MarkerFillSymbol fillSymbol = new MarkerFillSymbol();

                    fillSymbol.setOutline(null);

                    fillSymbol.setFillColor(null);

                    fillSymbol.getMarkerFillProperties().

                            setFillStyle(IMarkerFillPropertiesStyle.SINGLE_CENTERED_SYMBOL);

                    fillSymbol.setMarker(mSym);

                }

            }

            return mySymbol;

        }

    }

    /**

     * Fills the comboboxes that are placed in the panel with the classifying

     * field names of the layer which contain numerical information

     *

     */

    private void fillFieldNames() {

        // SelectableDataSource rs;

        try {

            FeatureStore fsto = (FeatureStore) ((FLyrVect) myLayer).getDataStore();

            FeatureType fty = fsto.getDefaultFeatureType();

            FeatureAttributeDescriptor[] atts = fty.getAttributeDescriptors();

            int cont = 0;

            for (int i = 0; i < atts.length; i++) {

                if (atts[i].getDataType().isNumeric()) {

                    cont++;

                }

            }

            String[] nomFields = new String[cont];

            cont = 0;

            for (int i = 0; i < atts.length; i++) {

                if (atts[i].getDataType().isNumeric()) {

                    nomFields[cont] = atts[i].getName();

                    cont++;

                }

            }

            this.fieldNames = nomFields;

            DefaultComboBoxModel cMValue = new DefaultComboBoxModel(this.fieldNames);

            DefaultComboBoxModel cMNormalization = new DefaultComboBoxModel(this.fieldNames);

            cmbValue.setModel(cMValue);

            cmbNormalization.setModel(cMNormalization);

            cmbNormalization.addItem(noNormalization);

        } catch (DataException e) {

            logger.info("Error while getting fields", e);

            ApplicationLocator.getManager().messageDialog(

                    Messages.getText("_Error_while_getting_fields"),

                    Messages.getText("error"),

                    JOptionPane.ERROR_MESSAGE);

            // NotificationManager.addError(PluginServices.getText(this, "recovering_recordset"), e);

        }

    }

    public void setData(FLayer lyr, ILegend legend) {

        this.myLayer = (ClassifiableVectorial) lyr;

        fillFieldNames();

        int myt = Geometry.TYPES.GEOMETRY;

        try {

            myt = this.myLayer.getGeometryType().getType();

        } catch (ReadException re) {

            logger.info("Error while getting geometry type", re);

            ApplicationLocator.getManager().message(

                    "Error getting geometry type",

                    JOptionPane.ERROR_MESSAGE);

        }

        templateShapeType

                = ProportionalSymbolsLegend.isPolygonal(myt)

                ? Geometry.TYPES.POINT : myt;

        getTemplSymbol().setShapeType(templateShapeType);

        if (ProportionalSymbolsLegend.isPolygonal(myt) && backgroundPanel == null) {

            symbolPanel.add(getBackgroundPanel());

        }

        if (ProportionalSymbolsLegend.class.equals(legend.getClass())) {

            auxLegend = (ProportionalSymbolsLegend) legend.cloneLegend();

            cmbValue.setSelectedItem(auxLegend.getClassifyingFieldNames()[0]);

            ISymbol defSymbol = auxLegend.getDefaultSymbol();

            if (((ProportionalSymbolsLegend) auxLegend).getUseNormalization()) {

                cmbNormalization.setSelectedItem(auxLegend.getClassifyingFieldNames()[1]);

            } else {

                cmbNormalization.setSelectedItem(noNormalization);

            }

            txtMaxSize.setDouble(auxLegend.getMaxSize());

            txtMinSize.setDouble(auxLegend.getMinSize());

            if (ProportionalSymbolsLegend.isLinear(templateShapeType)) {

                ((ILineSymbol) defSymbol).setLineWidth(2);

            } else {

                ((IMarkerSymbol) defSymbol).setSize(15);

            }

            getTemplSymbol().setSymbol(defSymbol);

            if (((ProportionalSymbolsLegend) auxLegend).getBackgroundSymbol() != null) {

                getBtnBackground().setSymbol(((ProportionalSymbolsLegend) auxLegend).getBackgroundSymbol());

            }

        } else {

            auxLegend = new ProportionalSymbolsLegend();

            auxLegend.setTemplateShapeType(templateShapeType);

            if (ProportionalSymbolsLegend.isLinear(templateShapeType)) {

                auxLegend.setDefaultSymbol(newSymbol(templateShapeType, 2));

            } else {

                auxLegend.setDefaultSymbol(newSymbol(templateShapeType, 15));

            }

            getTemplSymbol().setSymbol(auxLegend.getDefaultSymbol());

            if (ProportionalSymbolsLegend.isLinear(templateShapeType)) {

                txtMinSize.setDouble(3);

                txtMaxSize.setDouble(3);

            } else {

                txtMinSize.setDouble(10);

                txtMaxSize.setDouble(10);

            }

        }

    }

    public ILegend getLegend() {

        ProportionalSymbolsLegend theLegend = new ProportionalSymbolsLegend();

        String[] fieldNames = new String[2];

        fieldNames[0] = cmbValue.getSelectedItem().toString();

        if (!useNormalization) {

            fieldNames[1] = fieldNames[0];

        } else {

            fieldNames[1] = cmbNormalization.getSelectedItem().toString();

        }

        auxLegend.setTemplateShapeType(templateShapeType);

        auxLegend.setValueField(cmbValue.getSelectedItem().toString());

        auxLegend.setNormalizationField(cmbNormalization.getSelectedItem().toString());

        auxLegend.setUseNormalization(useNormalization);

        auxLegend.setMinSize(txtMinSize.getDouble());

        auxLegend.setMaxSize(txtMaxSize.getDouble());

        auxLegend.clear();

        ISymbol symbol = getTemplSymbol().getSymbol();

        symbol.setDescription(getSymbolDescription());

        auxLegend.setDefaultSymbol(symbol);

        auxLegend.setClassifyingFieldNames(fieldNames);

        // ==================================

        FLyrVect vect = (FLyrVect) myLayer;

        FeatureStore fsto = null;

        FeatureType fty = null;

        FeatureAttributeDescriptor[] atts = null;

        try {

            fsto = (FeatureStore) vect.getDataStore();

            fty = fsto.getDefaultFeatureType();

            int[] fieldTyp = new int[2];

            fieldTyp[0] = fty.getAttributeDescriptor(fieldNames[0]).getType();

            fieldTyp[1] = fty.getAttributeDescriptor(fieldNames[1]).getType();

            auxLegend.setClassifyingFieldTypes(fieldTyp);

            FeatureSet fset = fsto.getFeatureSet();

            DisposableIterator diter = fset.fastIterator();

            Feature fitem = null;

            double[] maxs = new double[fieldNames.length];

            double[] mins = new double[fieldNames.length];

            for (int i = 0; i < fieldNames.length; i++) {

                // init to worst values

                maxs[i] = -Double.MAX_VALUE;

                mins[i] = Double.MAX_VALUE;

            }

            double aux_dob = 0;

            while (diter.hasNext()) {

                fitem = (Feature) diter.next();

                for (int i = 0; i < fieldNames.length; i++) {

                    aux_dob = fitem.getDouble(fieldNames[i]);

                    if (aux_dob > maxs[i]) {

                        maxs[i] = aux_dob;

                    }

                    if (aux_dob < mins[i]) {

                        mins[i] = aux_dob;

                    }

                }

            }

            auxLegend.setMinFeature(mins[0]);

            auxLegend.setMaxFeature(maxs[0]);

        } catch (DataException e) {

            logger.info("Error while creating ProportionalSymbols legend", e);

            ApplicationLocator.getManager().message(

                    Messages.getText("_Error_while_creating_legend"),

                    JOptionPane.ERROR_MESSAGE);

        }

        //Just to avoid empty legend

        auxLegend.addSymbol(-Double.MAX_VALUE, symbol);

        if (auxLegend.isPolygonal(this.templateShapeType)) {

            auxLegend.setBackgroundSymbol(getBtnBackground().getSymbol());

        }

        theLegend = (ProportionalSymbolsLegend) auxLegend.cloneLegend();

        return theLegend;

    }

    /**

     * Creates the String which will be the description of the symbol. If the

     * selected normalization field is not "None", then the String created will

     * have this structure ValueField/NormalizationField. Else, if the user

     * select "None" for the normalization field,the string will show the

     * ValueField only.

     *

     * @return String        description for the symbol

     */

    private String getSymbolDescription() {

        String description = "";

        if (cmbValue.getSelectedItem() != null) {

            description += cmbValue.getSelectedItem().toString();

        }

        if (cmbNormalization.getSelectedItem().toString().compareTo(noNormalization) != 0) {

            description += " / " + cmbNormalization.getSelectedItem().toString();

        }

        return description;

    }

    public String getDescription() {

        return Messages.getText(

                "draw_quantities_using_symbol_size_to_show_exact_values");

    }

    public ImageIcon getIcon() {

        return IconThemeHelper.getImageIcon(

                "legend-overview-proportional-symbols");

    }

    public Class getParentClass() {

        return Quantities.class;

    }

    public String getTitle() {

        return Messages.getText("proportional_symbols");

    }

    public Class getLegendClass() {

        return ProportionalSymbolsLegend.class;

    }

    public boolean isSuitableFor(FLayer layer) {

        if (layer instanceof FLyrVect) {

            FLyrVect lyr = (FLyrVect) layer;

            try {

                if (lyr.getShapeType() == Geometry.TYPES.GEOMETRY) {

                    return false;

                }

                FeatureStore fsto = (FeatureStore) lyr.getDataStore();

                FeatureType fty = fsto.getDefaultFeatureType();

                FeatureAttributeDescriptor[] atts = fty.getAttributeDescriptors();

                for (int i = 0; i < atts.length; i++) {

                    if (atts[i].getDataType().isNumeric()) {

                        return true;

                    }

                }

            } catch (DataException e) {

                logger.info("Error in isSuitableFor", e);

                ApplicationLocator.getManager().message(

                        Messages.getText("_Error_while_checking_suitability"),

                        JOptionPane.ERROR_MESSAGE);

                return false;

            }

        }

        return false;

    }

    public JPanel getPanel() {

        return this;

    }

    private ActionListener action = new ActionListener() {

        public void actionPerformed(ActionEvent e) {

            if (e.getSource().equals(cmbValue)) {

                JComboBox cb = (JComboBox) e.getSource();

                auxLegend.setValueField(cb.getSelectedItem().toString());

            }

            if (e.getSource().equals(cmbNormalization)) {

                JComboBox cb = (JComboBox) e.getSource();

                if (cb.getSelectedItem().toString().compareTo(noNormalization) == 0) {

                    useNormalization = false;

                    auxLegend.setNormalizationField(cmbValue.getSelectedItem().toString());

                } else {

                    useNormalization = true;

                    auxLegend.setNormalizationField(cb.getSelectedItem().toString());

                }

                auxLegend.setUseNormalization(useNormalization);

            }

            if (e.getSource().equals(txtMinSize)) {

                if (txtMaxSize.getDouble() < txtMinSize.getDouble()) {

                    txtMaxSize.setDouble(txtMinSize.getDouble());

                }

            }

            if (e.getSource().equals(txtMaxSize)) {

                if (txtMaxSize.getDouble() < txtMinSize.getDouble()) {

                    txtMinSize.setDouble(txtMaxSize.getDouble());

                }

            }

        }

    };

}