Application: gvSIG desktop

/* 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.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.DefaultComboBoxModel;

import javax.swing.JButton;

import javax.swing.JCheckBox;

import javax.swing.JComboBox;

import javax.swing.JLabel;

import javax.swing.JOptionPane;

import javax.swing.JPanel;

import javax.swing.JTextField;

import org.apache.log4j.Logger;

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

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.cit.gvsig.fmap.DriverException;

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.v02.FSymbol;

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

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.Legend;

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 JPanel panelN = null;

    private JLabel lblField = null;

    private JComboBox cmbField = null;

    private JLabel lblNumIntervals = null;

    private JTextField txtNumIntervals = null;

    private JLabel lblInitColor = null;

    private JLabel lblEndColor = null;

    private ColorChooserPanel colorChooserPanel = null;

    private ColorChooserPanel colorChooserPanel1 = null;

    private JCheckBox chkdefaultvalues = null;

    private JLabel lblType = null;

    private JComboBox cmbFieldType = null;

    private JPanel panelS = null;

    private JButton bintervals = null;

    private JButton bInsert = null;

    private JButton bDelAll = null;

    private JButton bDel = null;

    private int count = 0;

    private ClassifiableVectorial m_lyr;

    private VectorialIntervalLegend m_Renderer;

    private VectorialIntervalLegend auxLegend = null;

    private FSymbolTable m_symbolTable = new FSymbolTable("intervals");

    private MyListener listener = new MyListener();

    private JPanel panelC = null;

        private PictureMarkerSymbol previewSymbol;

    /**

     * This is the default constructor

     */

    public VectorialInterval() {

        super();

        initialize();

    }

    /**

     * This method initializes this

     */

    private void initialize() {

        //this.setLayout(new BorderLayout());

        this.setLayout(new BorderLayout());

        this.setSize(490, 300);

        this.add(getPanelN(), java.awt.BorderLayout.NORTH);

        this.add(getPanelS(), java.awt.BorderLayout.SOUTH);

        this.add(getPanelC(), java.awt.BorderLayout.CENTER);

    }

    /**

     * This method initializes panelN

     *

     * @return javax.swing.JPanel

     */

    private JPanel getPanelN() {

        if (panelN == null) {

            lblType = new JLabel();

            lblType.setBounds(new java.awt.Rectangle(1, 26, 122, 20));

            lblType.setText(PluginServices.getText(this, "tipo_de_intervalo"));

            lblEndColor = new JLabel();

            lblEndColor.setBounds(new java.awt.Rectangle(169, 49, 84, 20));

            lblEndColor.setText(PluginServices.getText(this, "Color_final"));

            lblInitColor = new JLabel();

            lblInitColor.setBounds(new java.awt.Rectangle(1, 49, 105, 20));

            lblInitColor.setText(PluginServices.getText(this, "Color_inicio"));

            lblNumIntervals = new JLabel();

            lblNumIntervals.setBounds(new java.awt.Rectangle(315, 49, 133, 20));

            lblNumIntervals.setText(PluginServices.getText(this,

                    "No_de_intervalos"));

            lblField = new JLabel();

            lblField.setBounds(new java.awt.Rectangle(1, 3, 170, 20));

            lblField.setText(PluginServices.getText(this,

                    "Campo_de_clasificacion"));

            panelN = new JPanel();

            panelN.setLayout(null);

            panelN.setPreferredSize(new java.awt.Dimension(450, 75));

            panelN.add(lblField, null);

            panelN.add(getJComboBox(), null);

            panelN.add(lblNumIntervals, null);

            panelN.add(getTxtNumIntervals(), null);

            panelN.add(lblInitColor, null);

            panelN.add(lblEndColor, null);

            panelN.add(getColorChooserPanel(), null);

            panelN.add(getColorChooserPanel1(), null);

            panelN.add(getChkdefaultvalues(), null);

            panelN.add(lblType, null);

            panelN.add(getJComboBox1(), null);

        }

        return panelN;

    }

    /**

     * This method initializes jComboBox

     *

     * @return javax.swing.JComboBox

     */

    private JComboBox getJComboBox() {

        if (cmbField == null) {

            cmbField = new JComboBox();

            cmbField.setBounds(new java.awt.Rectangle(172, 3, 312, 20));

            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();

            txtNumIntervals.setText("5");

            txtNumIntervals.setBounds(new java.awt.Rectangle(449, 49, 37, 20));

        }

        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

     */

    private 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=m_Renderer;

                            if (chkdefaultvalues.isSelected()) {

                            addDefault();

                        } else {

                            delDefault();

                        }

                    }

                });

        }

        return chkdefaultvalues;

    }

    /**

     * This method initializes jComboBox1

     *

     * @return javax.swing.JComboBox

     */

    private JComboBox getJComboBox1() {

        if (cmbFieldType == null) {

            cmbFieldType = new JComboBox();

            cmbFieldType.setBounds(new java.awt.Rectangle(124, 26, 212, 20));

            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

     */

    private JPanel getPanelS() {

        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;

    }

    /**

     * 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.

     */

    private void fillTableValues() {

        FInterval[] arrayIntervalos = null;

        DataSource elRs;

        m_symbolTable.removeAllItems();

        try {

            elRs = ((AlphanumericData) m_lyr).getRecordset();

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

            elRs.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;

            }

            System.out.println("Nombre del campo de clasificaci?n: " +

                fieldName);

            m_Renderer.setFieldName(fieldName);

            String nomField = m_Renderer.getFieldName();

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

            // Creamos el primer y ?ltimo color.

            Color startColor = colorChooserPanel.getColor();

            m_Renderer.setStartColor(startColor);

            Color endColor = colorChooserPanel1.getColor();

            m_Renderer.setEndColor(endColor);

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

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

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

                    idField = i;

                    break;

                }

            }

            if (idField == -1) {

                System.err.println("Campo no reconocido " + nomField);

                return;

            }

            ///m_symbolTable.removeAllItems();

            ///m_valuesCache = new Object[m_lyr.getSource().getShapeCount()];

            int numSymbols = 0;

            FSymbol theSymbol;

            //Date valorDate;

            double minValue = Double.MAX_VALUE;

            double maxValue = Double.MIN_VALUE;

            //Date minValueDate = null;

            //Date maxValueDate = null;

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

            Value clave;

            //Object resul;

            int symbolType = 0;

            count = 0;

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

                clave = elRs.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;

                    symbolType = m_lyr.getShapeType();

                    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 (m_Renderer.getIntervalType()) {

                case VectorialIntervalLegend.EQUAL_INTERVALS:

                    arrayIntervalos = calculateEqualIntervals(numIntervalos,

                            minValue, maxValue, fieldName);

                    break;

                case VectorialIntervalLegend.NATURAL_INTERVALS:

                    arrayIntervalos = calculateNaturalIntervals(numIntervalos,

                            minValue, maxValue, fieldName);

                    break;

                case VectorialIntervalLegend.QUANTILE_INTERVALS:

                    arrayIntervalos = calculateQuantileIntervals(numIntervalos,

                            minValue, maxValue, fieldName);

                    break;

            }

            //intervals = arrayIntervalos;

            FInterval elIntervalo;

            NumberFormat.getInstance().setMaximumFractionDigits(2);

            m_Renderer.clear();

            int r;

            int g;

            int b;

            int stepR;

            int stepG;

            int stepB;

            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;

            if (chkdefaultvalues.isSelected()) {

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

                auxLegend.addSymbol(new NullIntervalValue(),

                    auxLegend.getDefaultSymbol());

            }

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

                elIntervalo = arrayIntervalos[k];

                // clave = elIntervalo; // elIntervalo.getMin() + " - " + elIntervalo.getMax();

                // System.out.println("k = " + k + " clave = " + clave);

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

                // if (!m_Renderer.m_symbolList.containsKey(elIntervalo)) {

                //si no esta creado el simbolo se crea

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

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

                    " - " +

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

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

                // CALCULAMOS UN COLOR APROPIADO

                r = r + stepR;

                g = g + stepG;

                b = b + stepB;

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

                auxLegend.addSymbol(elIntervalo, theSymbol);

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

                    " 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);

            m_symbolTable.fillTableFromSymbolList(auxLegend.getSymbols(),

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

            elRs.stop();

        } catch (DriverException e) {

            // TODO Auto-generated catch block

            e.printStackTrace();

        } catch (com.hardcode.gdbms.engine.data.driver.DriverException e) {

            e.printStackTrace();

        }

        bDelAll.setEnabled(true);

        bDel.setEnabled(true);

    }

    /**

     * 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.

     */

    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.

     */

    FInterval[] calculateNaturalIntervals(int numIntervals, double minValue,

        double maxValue, String fieldName) {

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

                fieldName, numIntervals);

        try {

            intervalGenerator.generarIntervalos();

        } catch (DriverException e) {

            e.printStackTrace();

        } catch (com.hardcode.gdbms.engine.data.driver.DriverException e) {

            e.printStackTrace();

        }

        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.

     */

    FInterval[] calculateQuantileIntervals(int numIntervals, double minValue,

        double maxValue, String fieldName) {

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

                fieldName, numIntervals);

        try {

            intervalGenerator.generarIntervalos();

        } catch (DriverException e) {

            e.printStackTrace();

        } catch (com.hardcode.gdbms.engine.data.driver.DriverException e) {

            e.printStackTrace();

        }

        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;

        /*        double numQ = count / numIntervals;

           for (int i = 0; i < count; i++) {

           }

           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.Legend)

     */

    public void setData(FLayer lyr, Legend r) {

        //                 m_TOC = t;

        // OJO, COMPROBAR ANTES SI ES DE TIPO VECTORIAL

        // m_lyr = (FLyrVect) t.getFirstLyrVectSelected();

        m_lyr = (ClassifiableVectorial) lyr;

        fillFieldNames();

        if (r instanceof VectorialIntervalLegend) {

            m_Renderer = (VectorialIntervalLegend) r;

            getChkdefaultvalues().setSelected(m_Renderer.isUseDefaultSymbol());

            cmbField.getModel().setSelectedItem(m_Renderer.getFieldName());

            m_symbolTable.fillTableFromSymbolList(m_Renderer.getSymbols(),

                m_Renderer.getValues(), m_Renderer.getDescriptions());

            colorChooserPanel.setColor(m_Renderer.getStartColor());

            colorChooserPanel1.setColor(m_Renderer.getEndColor());

            colorChooserPanel.repaint();

            colorChooserPanel1.repaint();

        } else {

            try {

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

                // una nueva del tipo que maneja este panel

                m_Renderer = new VectorialIntervalLegend(m_lyr.getShapeType());

            } catch (DriverException e) {

                // TODO Auto-generated catch block

                e.printStackTrace();

            }

        }

        cmbFieldType.setSelectedIndex(m_Renderer.getIntervalType());

    }

    /**

     * DOCUMENT ME!

     */

    private void fillFieldNames() {

        DataSource rs = null;

        ArrayList nomFields = null;

        try {

            rs = ((AlphanumericData) m_lyr).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 (com.hardcode.gdbms.engine.data.driver.DriverException e1) {

            e1.printStackTrace();

        } catch (DriverException e) {

            e.printStackTrace();

        }

        /*        ArrayList nomFields = new ArrayList();

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

                   if ((rs.getFieldType(i) == FRecordset.INTEGER) ||

                           (rs.getFieldType(i) == FRecordset.DECIMAL) ||

                           (rs.getFieldType(i) == FRecordset.DATE))

                   {

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

                   }

           }

         */

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

        cmbField.setModel(cM);

        // fieldsListValor.setSelectedIndex(0);

        m_symbolTable.removeAllItems();

    }

    /**

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

     */

    public Legend getLegend() {

        fillSymbolListFromTable();

        if (auxLegend != null) {

            m_Renderer.setDefaultSymbol(auxLegend.getDefaultSymbol());

            m_Renderer.useDefaultSymbol(chkdefaultvalues.isSelected());

        }

        return m_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() {

        //String clave;

        FSymbol theSymbol;

        IInterval theInterval = null;

        // Borramos las anteriores listas:

        m_Renderer.clear();

        //boolean bRestoValores = false; // PONERLO EN UN CHECKBOX

        //double from = 0;

        //double to = 0;

        //String[] arraySplit = new String[2];

        //int hasta;

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

        m_Renderer.setFieldName(fieldName);

        /*if (bRestoValores) {

           hasta = m_symbolTable.getRowCount() - 1;

           } else {

                   hasta = m_symbolTable.getRowCount();

           }

         */

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

            // clave = m_symbolTable.getFieldValue(row,1);

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

                theSymbol = (FSymbol) m_symbolTable.getFieldValue(row, 0);

                theSymbol.setDescription((String) m_symbolTable.getFieldValue(

                        row, 2));

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

            } else {

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

                theSymbol = (FSymbol) m_symbolTable.getFieldValue(row, 0);

                theSymbol.setDescription((String) m_symbolTable.getFieldValue(

                        row, 2));

                m_Renderer.addSymbol(theInterval, theSymbol);

            }

            ///m_Renderer.m_legendIntervals.add(theInterval);

        }

        /*        if (bRestoValores) {

           //m_Renderer.m_bUseDefaultSymbol = true;

           theSymbol = (FSymbol) m_symbolTable.getFieldValue(hasta, 0);

           m_Renderer.setDefaultSymbol(theSymbol);

           }*/

    }

    /**

     * This method initializes panelC

     *

     * @return javax.swing.JPanel

     */

    private JPanel getPanelC() {

        if (panelC == null) {

            panelC = new JPanel();

            panelC.setBorder(javax.swing.BorderFactory.createEmptyBorder(0, 0,

                    0, 0));

            panelC.setPreferredSize(new java.awt.Dimension(420, 200));

            panelC.add(m_symbolTable);

        }

        return panelC;

    }

    /**

     * 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());

        m_symbolTable.addTableRecord(auxLegend.getDefaultSymbol(),

            new NullIntervalValue(),

            auxLegend.getDefaultSymbol().getDescription());

        m_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());

        m_symbolTable.removeRow(new NullIntervalValue());

        m_symbolTable.repaint();

    }

    /**

     * Listener.

     *

     * @author Vicente Caballero Navarro

     */

    class MyListener implements ActionListener {

        //private FLyrShp m_layer;

        // private FPanelLegendValues m_Parent;

        public MyListener() { // FPanelLegendValues p) {

            // m_Parent = p;

        }

        /**

         * DOCUMENT ME!

         *

         * @param e DOCUMENT ME!

         */

        public void actionPerformed(ActionEvent e) {

            // rellenarValue();

            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);

                m_symbolTable.removeAllItems();

                m_Renderer.setFieldName(fieldName);

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

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

                if ((m_Renderer != null) &&

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

                    m_Renderer.setIntervalType(cb.getSelectedIndex());

                    m_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 {

                    m_symbolTable.addTableRecord(new FSymbol(

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

                } catch (DriverException e1) {

                    e1.printStackTrace();

                }

                /*        a?adir("Nuevo_Valor");

                   aceptar.setEnabled(true);

                   quitartodo.setEnabled(true);

                   quitar.setEnabled(true); */

            }

            //Vacia la tabla

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

                m_symbolTable.removeAllItems();

                // aceptar.setEnabled(false);

            }

            //Quitar solo el elemento seleccionado

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

                m_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 Categories.class;

        }

        public String getTitle() {

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

        }

        public JPanel getPanel() {

                return this;

        }

        public Class getLegendClass() {

                return VectorialIntervalLegend.class;

        }

}