| gvSIG desktop 1

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

 *

 * Copyright (C) 2004 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 com.iver.cit.gvsig.project.documents.view.legend.gui;

import java.awt.BorderLayout;

import java.awt.Color;

import java.awt.Component;

import java.awt.FlowLayout;

import java.awt.GridLayout;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.io.IOException;

import java.sql.Types;

import java.text.NumberFormat;

import java.util.ArrayList;

import javax.swing.BorderFactory;

import javax.swing.DefaultComboBoxModel;

import javax.swing.JButton;

import javax.swing.JCheckBox;

import javax.swing.JComboBox;

import javax.swing.JOptionPane;

import javax.swing.JPanel;

import javax.swing.JTextField;

import org.apache.log4j.Logger;

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

import com.hardcode.gdbms.driver.exceptions.ReadDriverException;

import com.hardcode.gdbms.engine.data.DataSource;

import com.hardcode.gdbms.engine.data.driver.DriverException;

import com.hardcode.gdbms.engine.values.DateValue;

import com.hardcode.gdbms.engine.values.DoubleValue;

import com.hardcode.gdbms.engine.values.FloatValue;

import com.hardcode.gdbms.engine.values.IntValue;

import com.hardcode.gdbms.engine.values.LongValue;

import com.hardcode.gdbms.engine.values.NullValue;

import com.hardcode.gdbms.engine.values.Value;

import com.iver.andami.PluginServices;

import com.iver.andami.messages.NotificationManager;

import com.iver.cit.gvsig.fmap.core.FShape;

import com.iver.cit.gvsig.fmap.core.SymbologyFactory;

import com.iver.cit.gvsig.fmap.core.styles.IMarkerFillProperties;

import com.iver.cit.gvsig.fmap.core.symbols.IFillSymbol;

import com.iver.cit.gvsig.fmap.core.symbols.ILineSymbol;

import com.iver.cit.gvsig.fmap.core.symbols.IMarkerSymbol;

import com.iver.cit.gvsig.fmap.core.symbols.ISymbol;

import com.iver.cit.gvsig.fmap.core.symbols.PictureMarkerSymbol;

import com.iver.cit.gvsig.fmap.core.symbols.SimpleFillSymbol;

import com.iver.cit.gvsig.fmap.core.symbols.SimpleLineSymbol;

import com.iver.cit.gvsig.fmap.core.symbols.SimpleMarkerSymbol;

import com.iver.cit.gvsig.fmap.layers.FLayer;

import com.iver.cit.gvsig.fmap.layers.FLyrVect;

import com.iver.cit.gvsig.fmap.layers.SelectableDataSource;

import com.iver.cit.gvsig.fmap.layers.layerOperations.AlphanumericData;

import com.iver.cit.gvsig.fmap.layers.layerOperations.ClassifiableVectorial;

import com.iver.cit.gvsig.fmap.rendering.FInterval;

import com.iver.cit.gvsig.fmap.rendering.IInterval;

import com.iver.cit.gvsig.fmap.rendering.ILegend;

import com.iver.cit.gvsig.fmap.rendering.LegendFactory;

import com.iver.cit.gvsig.fmap.rendering.NullIntervalValue;

import com.iver.cit.gvsig.fmap.rendering.VectorialIntervalLegend;

import com.iver.cit.gvsig.gui.panels.ColorChooserPanel;

import com.iver.cit.gvsig.project.documents.view.legend.NaturalIntervalGenerator;

import com.iver.cit.gvsig.project.documents.view.legend.QuantileIntervalGenerator;

/**

 * DOCUMENT ME!

 *

 * @author Vicente Caballero Navarro

 */

public class VectorialInterval extends JPanel implements ILegendPanel{

    private static Logger logger = Logger.getLogger(VectorialInterval.class.getName());

    private GridBagLayoutPanel pnlGeneral = null;

    protected JComboBox cmbField = null;

    protected JTextField txtNumIntervals = null;

    private ColorChooserPanel colorChooserPanel = null;

    private ColorChooserPanel colorChooserPanel1 = null;

    protected JCheckBox chkdefaultvalues = null;

    protected JComboBox cmbFieldType = null;

    private JPanel panelS = null;

    private JButton bintervals = null;

    private JButton bInsert = null;

    protected JButton bDelAll = null;

    protected JButton bDel = null;

    private int count = 0;

    protected ClassifiableVectorial layer;

    protected VectorialIntervalLegend renderer;

    protected VectorialIntervalLegend auxLegend = null;

    protected FSymbolTable symbolTable;

    private MyListener listener = new MyListener();

    protected JPanel pnlCenter = null;

    private PictureMarkerSymbol previewSymbol;

    protected JPanel optionPanel;

    private JPanel pnlNorth;

    /**

     * This is the default constructor

     */

    public VectorialInterval() {

        super();

        initialize();

    }

    /**

     * This method initializes this

     */

    private void initialize() {

        this.setLayout(new BorderLayout());

        this.setSize(490, 300);

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

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

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

        setOptionPanel(getOptionPanel());

    }

    private JPanel getPnlNorth() {

        if (pnlNorth == null) {

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

            pnlNorth.add(getGeneralPanel());

        }

        return pnlNorth;

    }

    /**

     * This method initializes panelN

     *

     * @return javax.swing.JPanel

     */

    private JPanel getGeneralPanel() {

        if (pnlGeneral == null) {

            pnlGeneral = new GridBagLayoutPanel();

            pnlGeneral.setBorder(BorderFactory.

                    createTitledBorder(null,

                            PluginServices.getText(this, "fields")));

            pnlGeneral.addComponent(PluginServices.getText(this, "Campo_de_clasificacion"),

                    getCmbFields());

            pnlGeneral.addComponent(PluginServices.getText(this, "tipo_de_intervalo"),

                    getCmbIntervalTypes());

            JPanel aux = new JPanel(new FlowLayout(FlowLayout.LEADING, 0, 0));

            aux.add(getTxtNumIntervals());

            pnlGeneral.addComponent(PluginServices.getText(this, "No_de_intervalos"),

                    aux);

            pnlGeneral.addComponent("", getChkDefaultvalues());

        }

        return pnlGeneral;

    }

    public JPanel getOptionPanel() {

        if (optionPanel == null) {

            optionPanel = new JPanel(new FlowLayout(FlowLayout.LEADING));

            optionPanel.setBorder(BorderFactory.

                    createTitledBorder(null,

                            PluginServices.getText(this, "color_ramp")));

            GridBagLayoutPanel aux = new GridBagLayoutPanel();

            aux.addComponent(PluginServices.getText(this, "Color_final"),

                    getColorChooserPanel());

            aux.addComponent(PluginServices.getText(this, "Color_inicio"),

                    getColorChooserPanel1());

            optionPanel.add(aux);

        }

        return optionPanel;

    }

    private void setOptionPanel(JPanel p) {

        getPnlNorth().remove(getOptionPanel());

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

    }

    /**

     * This method initializes jComboBox

     *

     * @return javax.swing.JComboBox

     */

    private JComboBox getCmbFields() {

        if (cmbField == null) {

            cmbField = new JComboBox();

            cmbField.setActionCommand("FIELD_SELECTED");

            cmbField.addActionListener(listener);

            cmbField.setVisible(true);

        }

        return cmbField;

    }

    /**

     * This method initializes txtNumIntervals

     *

     * @return javax.swing.JTextField

     */

    private JTextField getTxtNumIntervals() {

        if (txtNumIntervals == null) {

            txtNumIntervals = new JTextField(5);

            txtNumIntervals.setText("5");

        }

        return txtNumIntervals;

    }

    /**

     * This method initializes colorChooserPanel

     *

     * @return com.iver.cit.gvsig.gui.Panels.ColorChooserPanel

     */

    private ColorChooserPanel getColorChooserPanel() {

        if (colorChooserPanel == null) {

            colorChooserPanel = new ColorChooserPanel();

            colorChooserPanel.setBounds(new java.awt.Rectangle(108, 49, 54, 20));

            colorChooserPanel.setAlpha(255);

            colorChooserPanel.setColor(Color.red);

        }

        return colorChooserPanel;

    }

    /**

     * This method initializes colorChooserPanel1

     *

     * @return com.iver.cit.gvsig.gui.Panels.ColorChooserPanel

     */

    private ColorChooserPanel getColorChooserPanel1() {

        if (colorChooserPanel1 == null) {

            colorChooserPanel1 = new ColorChooserPanel();

            colorChooserPanel1.setBounds(new java.awt.Rectangle(251, 49, 54, 20));

            colorChooserPanel1.setAlpha(255);

            colorChooserPanel1.setColor(Color.blue);

        }

        return colorChooserPanel1;

    }

    /**

     * This method initializes chkdefaultvalues

     *

     * @return javax.swing.JCheckBox

     */

    protected JCheckBox getChkDefaultvalues() {

        if (chkdefaultvalues == null) {

            chkdefaultvalues = new JCheckBox();

            chkdefaultvalues.setText(PluginServices.getText(this,

            "resto_valores"));

            chkdefaultvalues.setBounds(new java.awt.Rectangle(342, 26, 141, 20));

            chkdefaultvalues.addActionListener(new java.awt.event.ActionListener() {

                public void actionPerformed(java.awt.event.ActionEvent e) {

                    if (auxLegend==null)auxLegend=renderer;

                    if (chkdefaultvalues.isSelected()) {

                        addDefault();

                    } else {

                        delDefault();

                    }

                }

            });

        }

        return chkdefaultvalues;

    }

    /**

     * This method initializes jComboBox1

     *

     * @return javax.swing.JComboBox

     */

    private JComboBox getCmbIntervalTypes() {

        if (cmbFieldType == null) {

            cmbFieldType = new JComboBox();

            cmbFieldType.setActionCommand("INTERVAL_TYPE");

            cmbFieldType.addActionListener(listener);

            cmbFieldType.addItem(PluginServices.getText(this, "equal_intervals"));

            cmbFieldType.addItem(PluginServices.getText(this,

                    "natural_intervals"));

            cmbFieldType.addItem(PluginServices.getText(this,

                    "quantile_intervals"));

            cmbFieldType.setVisible(true);

        }

        return cmbFieldType;

    }

    /**

     * This method initializes panelS

     *

     * @return javax.swing.JPanel

     */

    protected JPanel getPnlButtons() {

        if (panelS == null) {

            panelS = new JPanel();

            panelS.setPreferredSize(new java.awt.Dimension(417, 32));

            panelS.add(getBintervals(), null);

            panelS.add(getBInsert(), null);

            panelS.add(getBDelAll(), null);

            panelS.add(getBDel(), null);

        }

        return panelS;

    }

    /**

     * This method initializes bintervals

     *

     * @return javax.swing.JButton

     */

    private JButton getBintervals() {

        if (bintervals == null) {

            bintervals = new JButton();

            bintervals.setActionCommand("ADD_ALL_VALUES");

            bintervals.addActionListener(listener);

            bintervals.setText(PluginServices.getText(this,

                    "Calcular_intervalos"));

        }

        return bintervals;

    }

    /**

     * This method initializes bInsert

     *

     * @return javax.swing.JButton

     */

    private JButton getBInsert() {

        if (bInsert == null) {

            bInsert = new JButton();

            bInsert.setActionCommand("ADD_VALUE");

            bInsert.addActionListener(listener);

            bInsert.setText(PluginServices.getText(this, "Anadir"));

        }

        return bInsert;

    }

    /**

     * This method initializes bDelAll

     *

     * @return javax.swing.JButton

     */

    private JButton getBDelAll() {

        if (bDelAll == null) {

            bDelAll = new JButton();

            bDelAll.setActionCommand("REMOVE_ALL");

            bDelAll.addActionListener(listener);

            bDelAll.setText(PluginServices.getText(this, "Quitar_todos"));

        }

        return bDelAll;

    }

    /**

     * This method initializes bDel

     *

     * @return javax.swing.JButton

     */

    private JButton getBDel() {

        if (bDel == null) {

            bDel = new JButton();

            bDel.setText(PluginServices.getText(this, "Quitar"));

            bDel.setActionCommand("REMOVE");

            bDel.addActionListener(listener);

        }

        return bDel;

    }

    private ISymbol newSymbol(int shapeType, Color c) {

        ISymbol sym = SymbologyFactory.createDefaultSymbolByShapeType(shapeType);

        if (sym instanceof IMarkerSymbol) {

                sym = new SimpleMarkerSymbol();

            ((SimpleMarkerSymbol) sym).setColor(c);

        }

        if (sym instanceof ILineSymbol) {

            sym = new SimpleLineSymbol();

            ((SimpleLineSymbol) sym).setLineColor(c);

        }

        if (sym instanceof IFillSymbol) {

            sym = new SimpleFillSymbol();

            ((SimpleFillSymbol) sym).setFillColor(c);

        }

        return sym;

    }

    private ISymbol newSymbol(int shapeType) {

        ISymbol sym;

        switch (shapeType) {

        case FShape.POINT:

            sym = new SimpleMarkerSymbol();

            break;

        case FShape.LINE:

            sym = new SimpleLineSymbol();

            break;

        case FShape.POLYGON:

            sym = new SimpleFillSymbol();

            break;

        default:

            throw new Error("Unknown symbol type");

        }

        return sym;

    }

    /**

     * Damos una primera pasada para saber los l?mites inferior y superior y

     * rellenar un array con los valores. Luego dividimos ese array en

     * intervalos.

     */

    protected void fillTableValues() {

        symbolTable.removeAllItems();

        try {

            FInterval[] arrayIntervalos = calculateIntervals();

            if (arrayIntervalos == null)

                    return;

            //intervals = arrayIntervalos;

            FInterval interval;

            NumberFormat.getInstance().setMaximumFractionDigits(2);

            renderer.clear();

            int r;

            int g;

            int b;

            int stepR;

            int stepG;

            int stepB;

            // Cogemos el tipo de gradaci?n de colores que quiere el usuario y

            // Creamos el primer y ?ltimo color.

            Color startColor = colorChooserPanel.getColor();

            renderer.setStartColor(startColor);

            Color endColor = colorChooserPanel1.getColor();

            renderer.setEndColor(endColor);

            r = startColor.getRed();

            g = startColor.getGreen();

            b = startColor.getBlue();

            stepR = (endColor.getRed() - r) / arrayIntervalos.length;

            stepG = (endColor.getGreen() - g) / arrayIntervalos.length;

            stepB = (endColor.getBlue() - b) / arrayIntervalos.length;

            ISymbol theSymbol;

            if (chkdefaultvalues.isSelected()) {

                auxLegend.getDefaultSymbol().setDescription("Default");

                auxLegend.addSymbol(new NullIntervalValue(),

                    auxLegend.getDefaultSymbol());

            }

            int symbolType = layer.getShapeType();

            int numSymbols = 0;

            for (int k = 0; k < arrayIntervalos.length; k++) {

                interval = arrayIntervalos[k];

                theSymbol = newSymbol(symbolType, new Color(r, g, b));

                theSymbol.setDescription(NumberFormat.getInstance().format(interval.getMin()) +

                    " - " +

                    NumberFormat.getInstance().format(interval.getMax()));

                //////////////////////////////////////

                // CALCULAMOS UN COLOR APROPIADO

                r = r + stepR;

                g = g + stepG;

                b = b + stepB;

                /////////////////////////////////

                auxLegend.addSymbol(interval, theSymbol);

                System.out.println("addSymbol = " + interval +

                    " theSymbol = " + theSymbol.getDescription());

                numSymbols++;

                if (numSymbols > 100) {

                    int resp = JOptionPane.showConfirmDialog(this,

                            PluginServices.getText(this, "mas_de_100_simbolos"),

                            PluginServices.getText(this, "quiere_continuar"),

                            JOptionPane.YES_NO_OPTION,

                            JOptionPane.WARNING_MESSAGE);

                    if ((resp == JOptionPane.NO_OPTION) ||

                            (resp == JOptionPane.DEFAULT_OPTION)) {

                        return;

                    }

                }

                // }

            } // for

            System.out.println("Num. Simbolos = " +

                auxLegend.getValues().length);

            symbolTable.fillTableFromSymbolList(auxLegend.getSymbols(),

                auxLegend.getValues(), auxLegend.getDescriptions());

        } catch (ReadDriverException e) {

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

        }

        bDelAll.setEnabled(true);

        bDel.setEnabled(true);

    }

    protected FInterval[] calculateIntervals() {

            try {

                    FInterval[] intervalArray = null;

                    DataSource recordSet;

                    recordSet = ((AlphanumericData) layer).getRecordset();

                    logger.debug("elRs.start()");

                    recordSet.start();

                    int idField = -1;

                    int numIntervalos = 1;

                    try {

                            numIntervalos = Integer.parseInt(txtNumIntervals.getText());

                    } catch (NumberFormatException e) {

                            System.out.println("Foramto de n?mero erroneo");

                    }

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

                    if (fieldName==null) {

                            JOptionPane.showMessageDialog((Component)PluginServices.getMainFrame(),PluginServices.getText(this,"no_hay_campo_seleccionado"));

                            return null;

                    }

                    renderer.setFieldNames(new String[] {fieldName});

                    String[] nomField = renderer.getFieldNames();

                    for (int i = 0; i < recordSet.getFieldCount(); i++) {

                            String nomAux = recordSet.getFieldName(i).trim();

                            if (nomField[0].compareToIgnoreCase(nomAux) == 0) {

                                    idField = i;

                                    break;

                            }

                    }

                    if (idField == -1) {

                            logger.error("Campo no reconocido " + nomField);

                            return null;

                    }

                    //Date valorDate;

                    double minValue = Double.MAX_VALUE;

                    double maxValue = Double.NEGATIVE_INFINITY;

                    //Date minValueDate = null;

                    //Date maxValueDate = null;

                    auxLegend = LegendFactory.createVectorialIntervalLegend(layer.getShapeType());

                    Value clave;

                    //Object resul;

                    count = 0;

                    for (int j = 0; j < recordSet.getRowCount(); j++) {

                            clave = recordSet.getFieldValue(j, idField);

                            IInterval interval = auxLegend.getInterval(clave);

                            ////Comprobar que no esta repetido y no hace falta introducir en el hashtable el campo junto con el simbolo.

                            if (auxLegend.getSymbolByInterval(interval) == null) {

                                    //si no esta creado el simbolo se crea

                                    double valor = 0;

                                    if (clave instanceof IntValue) {

                                            valor = ((IntValue) clave).getValue();

                                    } else if (clave instanceof DoubleValue) {

                                            valor = ((DoubleValue) clave).getValue();

                                    } else if (clave instanceof FloatValue) {

                                            valor = ((FloatValue) clave).getValue();

                                    } else if (clave instanceof LongValue) {

                                            valor = ((LongValue) clave).getValue();

                                    } else if (clave instanceof DateValue) {

                                            //TODO POR IMPLEMENTAR

                                            ///valorDate = elRs.getFieldValueAsDate(idField);

                                            ///if (valorDate.before(minValueDate)) minValueDate = valorDate;

                                            ///if (valorDate.after(maxValueDate)) maxValueDate = valorDate;

                                    } else if (clave instanceof NullValue) {

                                            continue;

                                    }

                                    if (valor < minValue) {

                                            minValue = (double) valor;

                                    }

                                    if (valor > maxValue) {

                                            maxValue = (double) valor;

                                    }

                            }

                            count++;

                    }

                    switch (renderer.getIntervalType()) {

                    case VectorialIntervalLegend.EQUAL_INTERVALS:

                            intervalArray = calculateEqualIntervals(numIntervalos,

                                            minValue, maxValue, fieldName);

                            break;

                    case VectorialIntervalLegend.NATURAL_INTERVALS:

                            intervalArray = calculateNaturalIntervals(numIntervalos,

                                            minValue, maxValue, fieldName);

                            break;

                    case VectorialIntervalLegend.QUANTILE_INTERVALS:

                            intervalArray = calculateQuantileIntervals(numIntervalos,

                                            minValue, maxValue, fieldName);

                            break;

                    }

                    recordSet.stop();

                    return intervalArray;

            } catch (ReadDriverException e) {

                    return null;

            }

    }

    /**

     * EQUAL INTERVAL Devuelve un Array con el n?mero de intervalos que se

     * quieren crear. Los intervalos se crean con un tama?o igual entre ellos.

     *

     * @param numIntervals n?mero de intervalos

     * @param minValue Valor m?nimo.

     * @param maxValue Valor m?ximo.

     * @param fieldName Nombre del campo

     *

     * @return Array con los intervalos.

     */

    private FInterval[] calculateEqualIntervals(int numIntervals, double minValue,

        double maxValue, String fieldName) {

        FInterval[] theIntervalArray = new FInterval[numIntervals];

        double step = (maxValue - minValue) / numIntervals;

        if (numIntervals > 1) {

            theIntervalArray[0] = new FInterval(minValue, minValue + step);

            for (int i = 1; i < (numIntervals - 1); i++) {

                theIntervalArray[i] = new FInterval(minValue + (i * step) +

                        0.01, minValue + ((i + 1) * step));

            }

            theIntervalArray[numIntervals - 1] = new FInterval(minValue +

                    ((numIntervals - 1) * step) + 0.01, maxValue);

        } else {

            theIntervalArray[0] = new FInterval(minValue, maxValue);

        }

        return theIntervalArray;

    }

    /**

     * NATURAL INTERVAL Devuelve un Array con el n?mero de intervalos que se

     * quieren crear. Los intervalos se distribuyen de forma natural.

     *

     * @param numIntervals n?mero de intervalos

     * @param minValue Valor m?nimo.

     * @param maxValue Valor m?ximo.

     * @param fieldName Nombre del campo

     *

     * @return Array con los intervalos.

     */

    private FInterval[] calculateNaturalIntervals(int numIntervals, double minValue,

        double maxValue, String fieldName) {

        NaturalIntervalGenerator intervalGenerator = new NaturalIntervalGenerator(((AlphanumericData) layer),

                fieldName, numIntervals);

        try {

            intervalGenerator.generarIntervalos();

        } catch (ReadDriverException e) {

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

        }

        int numIntervalsGen = intervalGenerator.getNumIntervals() - 1;

        if (numIntervalsGen == -1) {

            //TODO cuando no puede calcular los intervalos.

            numIntervalsGen = 1;

        }

        FInterval[] theIntervalArray = new FInterval[numIntervalsGen];

        if (numIntervalsGen > 1) {

            theIntervalArray[0] = new FInterval(minValue,

                    intervalGenerator.getValorRuptura(0));

            for (int i = 1; i < (numIntervalsGen - 1); i++) {

                theIntervalArray[i] = new FInterval(intervalGenerator.getValInit(i -

                            1), intervalGenerator.getValorRuptura(i));

            }

            theIntervalArray[numIntervalsGen - 1] = new FInterval(intervalGenerator.getValInit(numIntervalsGen -

                        2), maxValue);

        } else {

            theIntervalArray[numIntervalsGen - 1] = new FInterval(minValue,

                    maxValue);

        }

        return theIntervalArray;

    }

    /**

     * QUANTILE INTERVAL Devuelve un Array con el n?mero de intervalos que se

     * quieren crear. Los intervalos se distribuyen de forma quantile.

     *

     * @param numIntervals n?mero de intervalos

     * @param minValue Valor m?nimo.

     * @param maxValue Valor m?ximo.

     * @param fieldName Nombre del campo

     *

     * @return Array con los intervalos.

     */

    private FInterval[] calculateQuantileIntervals(int numIntervals, double minValue,

        double maxValue, String fieldName) {

        QuantileIntervalGenerator intervalGenerator = new QuantileIntervalGenerator(((AlphanumericData) layer),

                fieldName, numIntervals);

        try {

            intervalGenerator.generarIntervalos();

        } catch (ReadDriverException e) {

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

        }

        int numIntervalsGen = intervalGenerator.getNumIntervalGen();

        FInterval[] theIntervalArray = new FInterval[numIntervalsGen];

        if (intervalGenerator.getNumIntervalGen() > 1) {

            theIntervalArray[0] = new FInterval(minValue,

                    intervalGenerator.getValRuptura(0));

            for (int i = 1; i < (numIntervalsGen - 1); i++) {

                theIntervalArray[i] = new FInterval(intervalGenerator.getValInit(i -

                            1), intervalGenerator.getValRuptura(i));

            }

            theIntervalArray[numIntervalsGen - 1] = new FInterval(intervalGenerator.getValInit(numIntervalsGen -

                        2), maxValue);

        } else {

            theIntervalArray[numIntervalsGen - 1] = new FInterval(minValue,

                    maxValue);

        }

        return theIntervalArray;

    }

    /**

     * @see com.iver.cit.gvsig.gui.legendmanager.panels.ILegendPanel#setData(com.iver.cit.gvsig.fmap.layers.FLayer,

     *      com.iver.cit.gvsig.fmap.rendering.ILegend)

     */

    public void setData(FLayer layer, ILegend legend) {

        this.layer = (ClassifiableVectorial) layer;

            int shapeType = 0;

            try {

                    shapeType = this.layer.getShapeType();

            } catch (ReadDriverException e) {

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

            }

            if (symbolTable != null)

                      pnlCenter.remove(symbolTable);

            symbolTable = new FSymbolTable("intervals", shapeType);

            pnlCenter.add(symbolTable);

        fillFieldNames();

        if (legend instanceof VectorialIntervalLegend) {

            renderer = (VectorialIntervalLegend) legend;

            getChkDefaultvalues().setSelected(renderer.isUseDefaultSymbol());

            cmbField.getModel().setSelectedItem(renderer.getFieldNames()[0]);

            symbolTable.fillTableFromSymbolList(renderer.getSymbols(),

                renderer.getValues(), renderer.getDescriptions());

            colorChooserPanel.setColor(renderer.getStartColor());

            colorChooserPanel1.setColor(renderer.getEndColor());

            colorChooserPanel.repaint();

            colorChooserPanel1.repaint();

        } else {

                        // Si la capa viene con otro tipo de leyenda, creamos

                        // una nueva del tipo que maneja este panel

                        renderer = new VectorialIntervalLegend();

        }

        cmbFieldType.setSelectedIndex(renderer.getIntervalType());

    }

    /**

     * DOCUMENT ME!

     */

    protected void fillFieldNames() {

        DataSource rs = null;

        ArrayList nomFields = null;

        try {

            rs = ((AlphanumericData) layer).getRecordset();

            logger.debug("rs.start()");

            rs.start();

            nomFields = new ArrayList();

            int type;

            for (int i = 0; i < rs.getFieldCount(); i++) {

                type = rs.getFieldType(i);

                if (type == Types.NULL) {

                    continue;

                }

                if ((type == Types.INTEGER) ||

                        (type == Types.DOUBLE) ||

                        (type == Types.FLOAT) ||

                        (type == Types.BIGINT)) {

                    nomFields.add(rs.getFieldName(i).trim());

                }

            }

            rs.stop();

        } catch (ReadDriverException e) {

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

        }

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

        cmbField.setModel(cM);

        symbolTable.removeAllItems();

    }

    /**

     * @see com.iver.cit.gvsig.gui.legendmanager.panels.ILegendPanel#getLegend()

     */

    public ILegend getLegend() {

        fillSymbolListFromTable();

        if (auxLegend != null) {

            renderer.setDefaultSymbol(auxLegend.getDefaultSymbol());

            renderer.useDefaultSymbol(chkdefaultvalues.isSelected());

        }

        return renderer;

    }

    /**

     * A partir de los registros de la tabla, regenera el FRenderer. (No solo

     * el symbolList, si no tambi?n el arrayKeys y el defaultRenderer

     */

    private void fillSymbolListFromTable() {

        ISymbol theSymbol;

        IInterval theInterval = null;

        // Borramos las anteriores listas:

        renderer.clear();

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

        renderer.setFieldNames(new String[] {fieldName});

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

            if (!(symbolTable.getFieldValue(row, 1) instanceof FInterval)) {

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

                theSymbol.setDescription((String) symbolTable.getFieldValue(

                        row, 2));

                renderer.addSymbol(new NullIntervalValue(), theSymbol);

            } else {

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

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

                theSymbol.setDescription((String) symbolTable.getFieldValue(

                        row, 2));

                renderer.addSymbol(theInterval, theSymbol);

            }

        }

    }

    /**

     * This method initializes panelC

     *

     * @return javax.swing.JPanel

     */

    private JPanel getPnlCenter() {

        if (pnlCenter == null) {

            pnlCenter = new JPanel();

        }

        return pnlCenter;

    }

    /**

     * A?ade la fila y el s?mbolo para el resto de valores no representados.

     */

    private void addDefault() {

        auxLegend.getDefaultSymbol().setDescription("Default");

        auxLegend.addSymbol(new NullIntervalValue(),

            auxLegend.getDefaultSymbol());

        symbolTable.addTableRecord(auxLegend.getDefaultSymbol(),

            new NullIntervalValue(),

            auxLegend.getDefaultSymbol().getDescription());

        symbolTable.repaint();

    }

    /**

     * Elimina la fila de la tabla y el s?mbolo del resto de valores no

     * representados por ning?n valor.

     */

    private void delDefault() {

        auxLegend.delSymbol(new NullIntervalValue());

        symbolTable.removeRow(new NullIntervalValue());

        symbolTable.repaint();

    }

    /**

     * Listener.

     *

     * @author Vicente Caballero Navarro

     */

    class MyListener implements ActionListener {

       public void actionPerformed(ActionEvent e) {

            System.out.println("ActionEvent con " + e.getActionCommand());

            //modificar el combobox de valor

            if (e.getActionCommand() == "FIELD_SELECTED") {

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

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

                System.out.println("Nombre del campo: " + fieldName);

                symbolTable.removeAllItems();

                renderer.setFieldNames(new String[] {fieldName});

            } else if (e.getActionCommand() == "INTERVAL_TYPE") {

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

                if ((renderer != null) &&

                        (cb.getSelectedIndex() != renderer.getIntervalType())) {

                    renderer.setIntervalType(cb.getSelectedIndex());

                    symbolTable.removeAllItems();

                }

            }

            //A?adir todos los elementos por valor

            if (e.getActionCommand() == "ADD_ALL_VALUES") {

                fillTableValues();

            }

            //A?adir un ?nico elemento

            if (e.getActionCommand() == "ADD_VALUE") {

                try {

                    symbolTable.addTableRecord(newSymbol(

                            layer.getShapeType()), new FInterval(0, 0), "0 - 0");

                } catch (ReadDriverException e1) {

                        NotificationManager.addError(PluginServices.getText(this, "could_not_get_shape_type"), e1);

                }

            }

            //Vacia la tabla

            if (e.getActionCommand() == "REMOVE_ALL") {

                symbolTable.removeAllItems();

            }

            //Quitar solo el elemento seleccionado

            if (e.getActionCommand() == "REMOVE") {

                symbolTable.removeSelectedRows();

            }

        }

    }

    public String getDescription() {

        return PluginServices.getText(this,"Muestra_los_elementos_de_la_capa_usando_una_gama_de_colores_en_funcion_del_valor_de_un_determinado_campo_de_atributos") + ".";

    }

    public ISymbol getPreviewSymbol() {

        if (previewSymbol == null) {

            try {

                previewSymbol = new PictureMarkerSymbol(

                        this.getClass().getClassLoader()

                                .getResource("images/Intervalos.png"));

            } catch (IOException e) {

                return null;

            }

        }

        return previewSymbol;

    }

    public Class getParentClass() {

        return Quantities.class;

    }

    public String getTitle() {

        return PluginServices.getText(this,"Intervalos");

    }

    public JPanel getPanel() {

        return this;

    }

    public Class getLegendClass() {

        return VectorialIntervalLegend.class;

    }

    private boolean isNumericField(int fieldType) {

                switch (fieldType) {

                case Types.BIGINT:

                case Types.DECIMAL:

                case Types.DOUBLE:

                case Types.FLOAT:

                case Types.INTEGER:

                case Types.NUMERIC:

                case Types.REAL:

                case Types.SMALLINT:

                case Types.TINYINT:

                        return true;

                default:

                        return false;

                }

        }

        public boolean isSuitableFor(FLayer layer) {

                if (layer instanceof FLyrVect) {

                        SelectableDataSource sds;

                        try {

                                sds = ((FLyrVect) layer).getRecordset();

                                String[] fNames = sds.getFieldNames();

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

                                        if (isNumericField(sds.getFieldType(i))) {

                                                return true;

                                        }

                                }

                        } catch (ReadDriverException e) {

                                return false;

                        }

                }

                return false;

        }

}