Application: gvSIG desktop » gvSIG legends: base legends

package org.gvsig.symbology.gui.layerproperties;

import java.awt.BorderLayout;

import java.awt.GridLayout;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.util.ArrayList;

import java.util.List;

import javax.swing.BorderFactory;

import javax.swing.DefaultComboBoxModel;

import javax.swing.ImageIcon;

import javax.swing.JButton;

import javax.swing.JComboBox;

import javax.swing.JComponent;

import javax.swing.JOptionPane;

import javax.swing.JPanel;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.gvsig.andami.IconThemeHelper;

import org.gvsig.andami.ui.mdiManager.IWindow;

import org.gvsig.andami.ui.mdiManager.WindowInfo;

import org.gvsig.app.ApplicationLocator;

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

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

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

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

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

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

import org.gvsig.fmap.mapcontext.MapContextLocator;

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

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

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

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

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

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

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

import org.gvsig.gui.beans.AcceptCancelPanel;

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

import org.gvsig.i18n.Messages;

import org.gvsig.symbology.fmap.mapcontext.rendering.legend.impl.VectorialIntervalLegend;

import org.gvsig.symbology.fmap.mapcontext.rendering.symbol.fill.IFillSymbol;

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

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

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

/**

 * Implements the panel of a legend where the user can compare two different characteristics

 * of a region in the map. These two "fields" will be compared, on one side,

 * using a color for the region and , on the other side, using a graduated symbol.

 * Both methods will change (the color or the size of the symbol) depending on

 * the value of the fields.

 *

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

 */

public class QuantityByCategoryPanel extends JPanel

implements ILegendPanel, ActionListener {

        private static final long serialVersionUID = 5098346573350040756L;

        private static final Logger logger =

            LoggerFactory.getLogger(QuantityByCategoryPanel.class);

        private JPanel pnlNorth;

        private JPanel pnlSouth;

        private JPanel pnlButtons;

        private GridBagLayoutPanel pnlFields;

        private JPanel pnlColorAndSymbol;

        private JComboBox cmbColorField;

        private JComboBox cmbGraduatedSymbolField;

        private JButton btnColor;

        private JButton btnSymbol;

//        private JButton btnDelete;

//        private JButton btnDeleteAll;

        private QuantityByCategoryLegend legend;

        private QuantityByCategoryLegend oldLegend;

        private FLayer layer;

        private SymbolTable symbolTable;

        /**

         * Constructor method

         */

        public QuantityByCategoryPanel() {

                super();

                initialize();

        }

        /**

         * This method initializes this

         */

        private void initialize() {

                this.setLayout(new BorderLayout());

                this.setSize(490, 300);

                this.add(getPnlNorth(), BorderLayout.NORTH);

                this.add(getPnlSouth(),BorderLayout.CENTER);

//                this.add(getPnlButtons(),BorderLayout.SOUTH);

        }

        /**

         * Obtains the south panel

         *

         * @return JPanel

         */

        private JPanel getPnlSouth() {

                if (pnlSouth == null) {

                        pnlSouth = new JPanel();

                        pnlSouth.setLayout(new BorderLayout());

                }

                return pnlSouth;

        }

        /**

         * Obtains the panel where the buttons will be placed

         *

         * @return JPanel

         */

//        private JPanel getPnlButtons() {

//                if(pnlButtons == null) {

//                        pnlButtons = new JPanel();

//                        pnlButtons.add(getButDel());

//                        pnlButtons.add(getButDelAll());

//                }

//                return pnlButtons;

//        }

        /**

         * Obtains the button that is used to delete all the rows of the symbolTable

         *

         * @return JButton

         */

//        private JButton getButDelAll() {

//                if (btnDeleteAll == null) {

//                        btnDeleteAll = new JButton();

//                        btnDeleteAll.addActionListener(this);

//                        btnDeleteAll.setText(PluginServices.getText(this, "Quitar_todos"));

//                }

//                return btnDeleteAll;

//        }

        /**

         * Obtains the button that is used to delete a row of the symbolTable

         *

         * @return JButton

         */

//        private JButton getButDel() {

//                if (btnDelete == null) {

//                        btnDelete = new JButton();

//                        btnDelete.addActionListener(this);

//                        btnDelete.setText(PluginServices.getText(this, "Quitar"));

//                }

//

//                return btnDelete;

//        }

        /**

         * Obtains the north panel

         *

         * @return JPanel

         */

        private JPanel getPnlNorth() {

                if (pnlNorth == null) {

                        pnlNorth = new JPanel(new GridLayout(1, 2));

                        pnlNorth.add(getPnlFields());

                        pnlNorth.add(getPnlColorAndSymbol());

                }

                return pnlNorth;

        }

        /**

         * Obtains the panel where the user has the options to select the variation to be applied

         *

         * @return JPanel

         */

        private JPanel getPnlColorAndSymbol() {

                if (pnlColorAndSymbol == null) {

                        pnlColorAndSymbol = new JPanel();

                        pnlColorAndSymbol.setBorder(

                                        BorderFactory.createTitledBorder(

                                                        null, Messages.getText("variation_by")));

                        pnlColorAndSymbol.add(getBtnColor());

                        pnlColorAndSymbol.add(getBtnSymbol());

                }

                return pnlColorAndSymbol;

        }

        /**

         * Creates the button which is used to selecte the variation by symbol

         *

         * @return JButton

         */

        private JButton getBtnSymbol() {

                if (btnSymbol == null) {

                        btnSymbol = new JButton(Messages.getText("symbol"));

                        btnSymbol.addActionListener(this);

                }

                return btnSymbol;

        }

        /**

         * Creates the button which is used to selecte the variation by color ramp

         *

         * @return JButton

         */

        private JButton getBtnColor() {

                if (btnColor == null) {

                        btnColor = new JButton(Messages.getText("color_ramp"));

                        btnColor.addActionListener(this);

                }

                return btnColor;

        }

        /**

         * Creates the panel where the JComboBoxes to select the fields for the variation will be placed

         *

         * @return GridBagLayoutPanel

         */

        private GridBagLayoutPanel getPnlFields() {

                if (pnlFields == null) {

                        pnlFields = new GridBagLayoutPanel();

                        pnlFields.setBorder(

                                        BorderFactory.createTitledBorder(

                                                        null, Messages.getText("value_fields")));

                        pnlFields.addComponent(

                            Messages.getText("color_field"), getCmbColorField());

                        pnlFields.addComponent(

                            Messages.getText("symbol_field") ,getCmbGraduatedField());

                }

                return pnlFields;

        }

        /**

         * Creates a JComboBox where the user will select the field for the symbol variation

         *

         * @return JComboBox

         */

        private JComboBox getCmbGraduatedField() {

                if (cmbGraduatedSymbolField == null) {

                        cmbGraduatedSymbolField = new JComboBox();

                        cmbGraduatedSymbolField.addActionListener(this);

                }

                return cmbGraduatedSymbolField;

        }

        /**

         * Creates a JComboBox where the user will select the field for the color ramp variation

         *

         * @return JComboBox

         */

        private JComboBox getCmbColorField() {

                if (cmbColorField == null) {

                        cmbColorField = new JComboBox();

                        cmbColorField.addActionListener(this);

                }

                return cmbColorField;

        }

        public void setData(FLayer lyr, ILegend legend) {

                this.layer = lyr;

                this.oldLegend = null;

                if (symbolTable != null)

                        pnlSouth.remove(symbolTable);

                symbolTable = new SymbolTable(

                    this, SymbolTable.INTERVALS_TYPE, Geometry.TYPES.GEOMETRY);

                pnlSouth.add(symbolTable,BorderLayout.CENTER);

                fillFieldNames();

                if (legend instanceof QuantityByCategoryLegend) {

            this.oldLegend = (QuantityByCategoryLegend) legend.cloneLegend();

                        cmbColorField.setSelectedItem(this.oldLegend.getColorRampLegend().getClassifyingFieldNames()[0]);

                        cmbGraduatedSymbolField.setSelectedItem(

                            this.oldLegend.getGraduatedSymbolsLegend()

                            .getClassifyingFieldNames()[0]);

                        symbolTable.removeAllItems();

                        this.fillTableSkipDefault(this.oldLegend);

                } else {

                        this.oldLegend = new QuantityByCategoryLegend();

                        String[] fnn = {

                (String) getCmbColorField().getSelectedItem(),

                (String) getCmbGraduatedField().getSelectedItem() };

                        this.oldLegend.setClassifyingFieldNames(fnn);

            try {

                FLyrVect lv = (FLyrVect) lyr;

                this.setFieldTypesFromFieldNames(lv, this.oldLegend, fnn);

                this.oldLegend.setShapeType(lv.getShapeType());

            } catch (Exception exc) {

                logger.info("Error while setting data in legend panel", exc);

                ApplicationLocator.getManager().messageDialog(

                    Messages.getText("error_trying_to_access_to_the_layer"),

                    Messages.getText("error"),

                    JOptionPane.ERROR_MESSAGE);

            }

                }

        }

        private void setFieldTypesFromFieldNames(

            FLyrVect vect,

            QuantityByCategoryLegend leg,

            String[] nn) throws DataException {

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

        FeatureType fty = fsto.getDefaultFeatureType();

        int[] fieldTypes  = new int[nn.length];

        FeatureAttributeDescriptor attdesc = null;

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

            attdesc = fty.getAttributeDescriptor(nn[i]);

            fieldTypes[i]= attdesc.getDataType().getType();

        }

        leg.setClassifyingFieldTypes(fieldTypes);

        }

        private void fillSymbolListFromTable() {

                ISymbol theSymbol;

                IInterval theInterval = null;

                // Borramos las anteriores listas:

                this.oldLegend.clear();

                FLyrVect vect = (FLyrVect) layer;

                try {

                    String[] fNames = this.oldLegend.getClassifyingFieldNames();

                        if (fNames != null) {

                            setFieldTypesFromFieldNames(vect, this.oldLegend, fNames);

                        }

                } catch (DataException e) {

            logger.info("Error while fillSymbolListFromTablel", e);

            ApplicationLocator.getManager().messageDialog(

                Messages.getText("could_not_setup_legend"),

                Messages.getText("error"),

                JOptionPane.ERROR_MESSAGE);

            return;

                }

                for (int row = 0; row < symbolTable.getRowCount(); row++) {

                        theInterval = (IInterval) symbolTable.getFieldValue(row, 1);

                        theSymbol = (ISymbol) symbolTable.getFieldValue(row, 0);

                        theSymbol.setDescription((String) symbolTable.getFieldValue(

                                        row, 2));

                        if (theSymbol instanceof IFillSymbol) {

                                this.oldLegend.getColorRampLegend().addSymbol(theInterval, theSymbol);

                        } else if (theSymbol instanceof IMarkerSymbol){

                                this.oldLegend.getGraduatedSymbolsLegend().addSymbol(theInterval, theSymbol);

                        }

                }

                if(oldLegend.getColorRampLegend().isUseDefaultSymbol())

                        this.oldLegend.getColorRampLegend().addSymbol(

                            null, oldLegend.getColorRampLegend().getDefaultSymbol());

                if(oldLegend.getGraduatedSymbolsLegend().isUseDefaultSymbol())

                        this.oldLegend.getGraduatedSymbolsLegend().addSymbol(

                            null, oldLegend.getGraduatedSymbolsLegend().getDefaultSymbol());

        }

        public ILegend getLegend() {

                fillSymbolListFromTable();

        this.legend = (QuantityByCategoryLegend) this.oldLegend.cloneLegend();

                return this.legend;

        }

        public String getDescription() {

                return Messages.getText("draw_quantities_for_each_category");

        }

        public ImageIcon getIcon() {

            ImageIcon ii = IconThemeHelper.getImageIcon(

                "legend-overview-quantity-by-category");

            return ii;

        }

        public Class getParentClass() {

                return MultipleAttributes.class;

        }

        public String getTitle() {

                return Messages.getText("quantity_by_category");

        }

        public JPanel getPanel() {

                return this;

        }

        public Class getLegendClass() {

                return QuantityByCategoryLegend.class;

        }

        public void actionPerformed(ActionEvent e) {

                JComponent c = (JComponent) e.getSource();

                if (c.equals(getBtnColor())) {

                        VectorialIntervalLegend colorRamp = this.oldLegend.getColorRampLegend();

                        String fieldName = (String) getCmbColorField().getSelectedItem();

                        if (!fieldName.equals(colorRamp.getClassifyingFieldNames()[0])) {

                                // if classification field has changed, clear the legend

                                colorRamp.setClassifyingFieldNames(new String[] {fieldName});

                                colorRamp.clear();

                        }

                        // create a new modal window to edit the color ramp legend

                        VectorialInterval legPanel = new VectorialInterval();

                        legPanel.setData(layer, colorRamp);

                        InnerWindow window = new InnerWindow(legPanel);

                        ApplicationLocator.getManager().getUIManager().addWindow(window);

                        cmbColorField.setSelectedItem(colorRamp.getClassifyingFieldNames()[0].toString());

                        ILegend newLegend = window.getLegend();

                        if (newLegend != null) {

                                if (newLegend instanceof VectorialIntervalLegend) {

                        this.oldLegend.getColorRampLegend().clear();

                        this.oldLegend.setColorRampLegend(

                            (VectorialIntervalLegend) newLegend);

                                } else {

                            ApplicationLocator.getManager().messageDialog(

                                Messages.getText("could_not_setup_legend"),

                                Messages.getText("error"),

                                JOptionPane.ERROR_MESSAGE);

                                }

                        }

                        symbolTable.removeAllItems();

                        this.fillTableSkipDefault(this.oldLegend);

                } else if (c.equals(getBtnSymbol())) {

                        GraduatedSymbolsLegend graduatedSymbol =

                            this.oldLegend.getGraduatedSymbolsLegend();

                        String fieldName = (String) getCmbGraduatedField().getSelectedItem();

                        if (!fieldName.equals(graduatedSymbol.getClassifyingFieldNames()[0])) {

                                // if classification field has changed, clear the legend

                                graduatedSymbol.setClassifyingFieldNames(new String[] {fieldName});

                        ISymbol def = MapContextLocator.getSymbolManager().

                            createSymbol(Geometry.TYPES.POINT);

                                graduatedSymbol.setDefaultSymbol(def);

                                graduatedSymbol.setMinSymbolSize(1);

                                graduatedSymbol.setMaxSymbolSize(14);

                                graduatedSymbol.clear();

                        }

                        // create a new modal window to edit the graduated symbol legend

                        GraduatedSymbolsPanel legPanel = new GraduatedSymbolsPanel(false);

                        legPanel.setData(layer, graduatedSymbol);

                        InnerWindow window = new InnerWindow(legPanel);

                        ApplicationLocator.getManager().getUIManager().addWindow(window);

                        cmbGraduatedSymbolField.setSelectedItem(graduatedSymbol.getClassifyingFieldNames()[0].toString());

                        ILegend newLegend = window.getLegend();

                        if(newLegend != null) {

                            if (newLegend instanceof GraduatedSymbolsLegend) {

                        this.oldLegend.getGraduatedSymbolsLegend().clear();

                        this.oldLegend.setGraduateSymbolLegend(

                            (GraduatedSymbolsLegend) newLegend);

                            } else {

                    ApplicationLocator.getManager().messageDialog(

                        Messages.getText("could_not_setup_legend"),

                        Messages.getText("error"),

                        JOptionPane.ERROR_MESSAGE);

                            }

                        }

                        symbolTable.removeAllItems();

                        this.fillTableSkipDefault(this.oldLegend);

                }

                else if (c.equals(getCmbColorField())) {

                        symbolTable.removeAllItems();

                        this.fillTableSkipDefault(

                            this.oldLegend.getGraduatedSymbolsLegend().getSymbols(),

                            this.oldLegend.getGraduatedSymbolsLegend().getValues(),

                            this.oldLegend.getDescriptions());

                }

                else if (c.equals(getCmbGraduatedField())) {

                        symbolTable.removeAllItems();

                        this.fillTableSkipDefault(

                            this.oldLegend.getColorRampLegend().getSymbols(),

                            this.oldLegend.getColorRampLegend().getValues(),

                            this.oldLegend.getDescriptions());

                }

//                if (c.equals(getButDel())) {

//                        symbolTable.removeSelectedRows();

//                }

//

//                else if(c.equals(getButDelAll())) {

//                        symbolTable.removeAllItems();

//                }

        }

        private class InnerWindow extends JPanel implements IWindow {

                private ActionListener okAction = new ActionListener() {

                        public void actionPerformed(ActionEvent e) {

                                legend = panel.getLegend();

                                ApplicationLocator.getManager().getUIManager()

                                .closeWindow(InnerWindow.this);

                        }

                }, cancelAction = new ActionListener() {

                        public void actionPerformed(ActionEvent e) {

                ApplicationLocator.getManager().getUIManager()

                .closeWindow(InnerWindow.this);

                        }

                };

                private ILegend legend;

                private ILegendPanel panel;

                private WindowInfo wi;

                public InnerWindow(ILegendPanel panel) {

                        this.panel = panel;

                        this.setLayout(new BorderLayout());

                        add((JComponent) panel, BorderLayout.NORTH);

                        add(new AcceptCancelPanel(okAction, cancelAction), BorderLayout.SOUTH);

                }

                public ILegend getLegend() {

                        return legend;

                }

                public WindowInfo getWindowInfo() {

                        if (wi == null) {

                                wi = new WindowInfo(WindowInfo.MODALDIALOG | WindowInfo.RESIZABLE);

                                JComponent c = (JComponent) panel;

                                wi.setWidth(c.getWidth());

                                wi.setHeight(c.getHeight());

                                wi.setTitle(panel.getTitle());

                        }

                        return wi;

                }

                public Object getWindowProfile() {

                        return WindowInfo.DIALOG_PROFILE;

                }

        }

        /**

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

         * classifying field names of the layer

         *

         */

        protected void fillFieldNames() {

                ArrayList<String> nomFields = null;

                FLyrVect vect = null;

                try {

            FeatureStore fsto = null;

            FeatureType fty = null;

            FeatureAttributeDescriptor[] atts = null;

                        if (layer instanceof FLyrVect) {

                            vect = (FLyrVect) layer;

                    fsto = (FeatureStore) vect.getDataStore();

                    fty = fsto.getDefaultFeatureType();

                    atts = fty.getAttributeDescriptors();

                        } else {

                    ApplicationLocator.getManager().messageDialog(

                        Messages.getText("error_trying_to_access_to_the_layer"),

                        Messages.getText("error"),

                        JOptionPane.ERROR_MESSAGE);

                    logger.info("Error while fillFieldNames, Unexpected layer class: "

                        + layer);

                    return;

                        }

                        nomFields = new ArrayList<String>();

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

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

                    nomFields.add(atts[i].getName());

                            }

                        }

                } catch (DataException e) {

            ApplicationLocator.getManager().messageDialog(

                Messages.getText("error_trying_to_access_to_the_layer"),

                Messages.getText("error"),

                JOptionPane.ERROR_MESSAGE);

            logger.info("Error while fillFieldNames", e);

            nomFields = new ArrayList<String>();

                }

                DefaultComboBoxModel cM = new DefaultComboBoxModel(nomFields.toArray());

                cmbColorField.setModel(cM);

                cM = new DefaultComboBoxModel(nomFields.toArray());

                cmbGraduatedSymbolField.setModel(cM);

                symbolTable.removeAllItems();

        }

        public boolean isSuitableFor(FLayer layer) {

                if (layer instanceof FLyrVect) {

                        try {

                                FLyrVect vect = (FLyrVect) layer;

                                int shpt = vect.getGeometryType().getType();

                                if (!QuantityByCategoryLegend.isPolygonal(shpt)) {

                                    return false;

                                }

                FeatureStore fsto = (FeatureStore) vect.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 (Exception e) {

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

                    ApplicationLocator.getManager().message(

                        Messages.getText("error"),

                        JOptionPane.ERROR_MESSAGE);

                                return false;

                        }

                }

                return false;

        }

        // reemplazar esto por arriba

    private void fillTableSkipDefault(

        IClassifiedLegend leg) {

        Object[] src_expr = leg.getValues();

        ISymbol[] src_syms = leg.getSymbols();

        String[] src_descs = leg.getDescriptions();

        List syms = new ArrayList();

        List vals = new ArrayList();

        List descs = new ArrayList();

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

            if (src_expr[i] instanceof IInterval) {

                syms.add(src_syms[i]);

                vals.add(src_expr[i]);

                descs.add(src_descs[i]);

            }

        }

        symbolTable.fillTableFromSymbolList(

            (ISymbol[]) syms.toArray(new ISymbol[0]),

            (Object[]) vals.toArray(new Object[0]),

            (String[]) descs.toArray(new String[0]));

    }

    private void fillTableSkipDefault(

        ISymbol[] src_syms,

        Object[] src_expr,

        String[] src_descs) {

        List syms = new ArrayList();

        List vals = new ArrayList();

        List descs = new ArrayList();

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

            if (src_expr[i] instanceof IInterval) {

                syms.add(src_syms[i]);

                vals.add(src_expr[i]);

                descs.add(src_descs[i]);

            }

        }

        symbolTable.fillTableFromSymbolList(

            (ISymbol[]) syms.toArray(new ISymbol[0]),

            (Object[]) vals.toArray(new Object[0]),

            (String[]) descs.toArray(new String[0]));

    }

}