gvSIG tools: basic charts

package org.gvsig.project.documents.view.legend.gui;

import java.awt.BorderLayout;

import java.awt.Color;

import java.awt.Dimension;

import java.awt.FlowLayout;

import java.awt.Font;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.sql.Types;

import java.util.ArrayList;

import java.util.Iterator;

import java.util.Random;

import javax.swing.BorderFactory;

import javax.swing.DefaultListModel;

import javax.swing.ImageIcon;

import javax.swing.JButton;

import javax.swing.JCheckBox;

import javax.swing.JLabel;

import javax.swing.JList;

import javax.swing.JPanel;

import javax.swing.JScrollPane;

import javax.swing.border.TitledBorder;

import javax.swing.event.ChangeEvent;

import javax.swing.event.ChangeListener;

import org.gvsig.andami.IconThemeHelper;

import org.gvsig.andami.PluginServices;

import org.gvsig.andami.messages.NotificationManager;

import org.gvsig.app.gui.panels.ColorChooserPanel;

import org.gvsig.app.gui.styling.JComboBoxColorScheme;

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

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

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

import org.gvsig.chart.ChartLocator;

import org.gvsig.chart.ChartManager;

import org.gvsig.chart.ChartProperties;

import org.gvsig.chart.ChartService;

import org.gvsig.chart.legend.IChartLegend;

import org.gvsig.chart.legend.ILinkedChartLegend;

import org.gvsig.chart.legend.IPieChartLegend;

import org.gvsig.chart.legend.symbols.IChartSymbol;

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

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

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

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

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

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

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

import org.gvsig.fmap.mapcontext.MapContextLocator;

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

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

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

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

import org.gvsig.project.documents.view.legend.PieChartLegend;

import org.gvsig.tools.dataTypes.DataTypes;

import org.gvsig.tools.dispose.DisposableIterator;

import org.gvsig.tools.service.ServiceException;

public class ChartLegendPanelPie extends JPanel implements ILegendPanel {

    /**

     *

     */

    private static final long serialVersionUID = -5009857246030623420L;

    // private PreviewBarSymbol previewPanel = null;

    private FLyrVect layer;

    private int shapeType;

    private IChartLegend auxLegend; // @jve:decl-index=0:

    private IChartLegend theLegend;

    private JPanel centerPanel = null; // @jve:decl-index=0:visual-constraint="10,10"

    private JScrollPane jScrollPane = null;

    private JList jFieldList = null;

    private Random rand = new Random(System.currentTimeMillis());

    private JPanel buttons = null;

    private JButton addButton = null;

    private JButton removeButton = null;

    private JButton addAllButton = null;

    private JButton removeAllButton = null;

    private JPanel pCentral = null;

    private FieldsTable fieldsTable = null; // @jve:decl-index=0:visual-constraint="746,10"

    private JPanel northPanel = null;

    private JPanel southPanel = null;

    private JButton bSize = null;

    private JPanel symbolPanel = null;

    private JLabel lBackgroundSymbol = null;

    private JSymbolPreviewButton bSymbolBackground = null;

    private JComboBoxColorScheme colorCombo = null;

    private JLabel lColorSchema = null;

    private JCheckBox ckOnlySelection = null;

    private JPanel eastPanel;

    private JPanel outlinePanel;

    private JLabel jLabel;

    private JCheckBox jCheckBox;

    private JCheckBox jShowAxis;

    private JPanel jPanel;

    private JLabel jLabel1;

    private JPanel jPanel1;

    private JNumberSpinner comboWidth;

    private JPanel dimensionPanel;

    private JCheckBox ck3D;

    private ColorChooserPanel colorButton;

    /**

     * This is the default constructor

     */

    public ChartLegendPanelPie() {

        super();

        initialize();

    }

    /**

     * This method initializes this

     *

     * @return void

     */

    private void initialize() {

        this.setPreferredSize(new Dimension(732, 354));

        this.setLayout(new BorderLayout());

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

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

        this.add(getEastPanel(), BorderLayout.EAST);

    }

    private JPanel getEastPanel() {

        if (eastPanel == null) {

            eastPanel = new JPanel();

            eastPanel.setLayout(new BorderLayout());

            eastPanel.setPreferredSize(new Dimension(150, 52));

            // eastPanel.add(getPreviewChart(), BorderLayout.NORTH);

            eastPanel.add(getOutlinePanel(), BorderLayout.CENTER);

            eastPanel.add(getDimensionPanel(), BorderLayout.SOUTH);

        }

        return eastPanel;

    }

    private JPanel getDimensionPanel() {

        if (dimensionPanel == null) {

            dimensionPanel = new JPanel();

            dimensionPanel.setLayout(new BorderLayout());

            dimensionPanel.setBorder(BorderFactory.createTitledBorder(null,

                    PluginServices.getText(this, "dimension"),

                    TitledBorder.DEFAULT_JUSTIFICATION,

                    TitledBorder.DEFAULT_POSITION, new Font("Dialog",

                            Font.BOLD, 12), new Color(51, 51, 51)));

            dimensionPanel.setPreferredSize(new Dimension(150, 50));

            dimensionPanel.add(getCk3D(), BorderLayout.NORTH);

        }

        return dimensionPanel;

    }

    private JCheckBox getCk3D() {

        if (ck3D == null) {

            ck3D = new JCheckBox();

            ck3D.setEnabled(false);

            ck3D.setText(PluginServices.getText(this, "display_3d"));

        }

        return ck3D;

    }

    private JPanel getOutlinePanel() {

        if (outlinePanel == null) {

            jLabel = new JLabel();

            jLabel.setText(PluginServices.getText(this, "color"));

            outlinePanel = new JPanel();

            outlinePanel.setLayout(new BorderLayout());

            outlinePanel.setBorder(BorderFactory.createTitledBorder(null,

                    PluginServices.getText(this, "background_color"),

                    TitledBorder.DEFAULT_JUSTIFICATION,

                    TitledBorder.DEFAULT_POSITION, new Font("Dialog",

                            Font.BOLD, 12), new Color(51, 51, 51)));

            outlinePanel.setPreferredSize(new Dimension(150, 115));

            outlinePanel.add(getJCheckBox(), BorderLayout.NORTH);

            outlinePanel.add(getJPanel(), BorderLayout.CENTER);

            //outlinePanel.add(getJPanel1(), BorderLayout.SOUTH);

        }

        return outlinePanel;

    }

    private JPanel getJPanel() {

        if (jPanel == null) {

            jPanel = new JPanel();

            jPanel.setLayout(new FlowLayout());

            jPanel.add(jLabel, null);

            jPanel.add(getColorButton(), null);

        }

        return jPanel;

    }

    private ColorChooserPanel getColorButton() {

        if (colorButton == null) {

            colorButton = new ColorChooserPanel(true);

            colorButton.setColor(Color.black);

            colorButton.addActionListener(new ActionListener() {

                public void actionPerformed(ActionEvent e) {

                    auxLegend.setOutlineColor(colorButton.getColor());

                }

            });

        }

        return colorButton;

    }

    /**

     * This method initializes jPanel1

     *

     * @return javax.swing.JPanel

     */

    private JPanel getJPanel1() {

        if (jPanel1 == null) {

            jLabel1 = new JLabel();

            jLabel1.setText(PluginServices.getText(this, "width"));

            jPanel1 = new JPanel();

            jPanel1.setLayout(new FlowLayout());

            jPanel1.add(jLabel1, null);

            jPanel1.add(getComboWidth(), null);

        }

        return jPanel1;

    }

    private JNumberSpinner getComboWidth() {

        if (comboWidth == null) {

            comboWidth = new JNumberSpinner(String.valueOf(1), 3, 0, Integer.MAX_VALUE, 1);

            comboWidth.addActionListener(new ActionListener() {

                public void actionPerformed(ActionEvent e) {

                    auxLegend.setOutlineWidth(comboWidth.getInteger());

                }

            });

        }

        return comboWidth;

    }

    private JCheckBox getShowAxis() {

        if (jShowAxis == null) {

            jShowAxis = new JCheckBox();

            jShowAxis.setEnabled(false);

            jShowAxis.setText(PluginServices.getText(this, "show_axis"));

        }

        return jShowAxis;

    }

    private JCheckBox getJCheckBox() {

        if (jCheckBox == null) {

            jCheckBox = new JCheckBox();

            jCheckBox.setText(PluginServices.getText(this, "Show"));

            jCheckBox.addChangeListener(new ChangeListener() {

                public void stateChanged(ChangeEvent e) {

                    if(auxLegend!=null){

                        auxLegend.setOutlineShow(jCheckBox.isSelected());

                    }

                }

            });

        }

        return jCheckBox;

    }

    private JPanel getSouthPanel() {

        if (southPanel == null) {

            southPanel = new JPanel();

            southPanel.setLayout(new FlowLayout());

            southPanel.setPreferredSize(new Dimension(241, 90));

            southPanel.add(getSymbolPanel(), null);

            southPanel.add(getNorthPanel(), null);

            southPanel.add(getBSize(), null);

            southPanel.add(getCkOnlySelection(), null);

        }

        return southPanel;

    }

    private JPanel getSymbolPanel() {

        if (symbolPanel == null) {

            lBackgroundSymbol = new JLabel();

            lBackgroundSymbol.setText(PluginServices.getText(this,

                    "background_symbol"));

            lBackgroundSymbol.setText(PluginServices.getText(this,

                    "show_axis"));

            symbolPanel = new JPanel();

            symbolPanel.setLayout(new FlowLayout());

            symbolPanel.setPreferredSize(new Dimension(241, 40));

//                        symbolPanel.add(lBackgroundSymbol, null);

//                        symbolPanel.add(getBackgroundSymbol(), null);

            symbolPanel.add(getShowAxis(), null);

        }

        return symbolPanel;

    }

    private JSymbolPreviewButton getBackgroundSymbol() {

        if (bSymbolBackground == null) {

            bSymbolBackground = new JSymbolPreviewButton(shapeType);

            bSymbolBackground.setPreferredSize(new Dimension(110, 20));

            bSymbolBackground.addActionListener(new ActionListener() {

                public void actionPerformed(ActionEvent e) {

                    // getPreviewChart().setBackgroundSymbol(bSymbolBackground.getSymbol());

                    // getPreviewChart().repaint();

                }

            });

        }

        return bSymbolBackground;

    }

    private JButton getBSize() {

        if (bSize == null) {

            bSize = new JButton();

            bSize.setText(PluginServices.getText(this, "size"));

            bSize.setPreferredSize(new Dimension(100, 30));

            bSize.setMaximumSize(new Dimension(100, 30));

            bSize.addActionListener(new ActionListener() {

                public void actionPerformed(ActionEvent e) {

                    PluginServices.getMDIManager().addCentredWindow(

                            new SizePanel(layer, (IChartLegend) getLegend()));

                }

            });

        }

        return bSize;

    }

    /**

     * This method initializes centerPanel

     *

     * @return javax.swing.JPanel

     */

    private JPanel getCenterPanel() {

        if (centerPanel == null) {

            centerPanel = new JPanel();

            centerPanel.setLayout(new BorderLayout());

            centerPanel.setPreferredSize(new Dimension(350, 300));

            centerPanel.add(getJScrollPane(), BorderLayout.WEST);

            centerPanel.add(getButtons(), BorderLayout.CENTER);

            centerPanel.add(getFieldsTable(), java.awt.BorderLayout.EAST);

        }

        return centerPanel;

    }

    private JPanel getPCentral() {

        if (pCentral == null) {

            pCentral = new JPanel();

            pCentral.setLayout(new FlowLayout());

            pCentral.setPreferredSize(new Dimension(50, 185));

            pCentral.add(getRemoveAllButton(), null);

            pCentral.add(getAddAllButton(), null);

            pCentral.add(getRemoveButton(), null);

            pCentral.add(getAddButton(), null);

        }

        return pCentral;

    }

    private JButton getAddButton() {

        if (addButton == null) {

            addButton = new JButton();

            addButton.setText(">");

            addButton.setPreferredSize(new Dimension(50, 40));

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

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

                    Object[] fields = getJFieldList().getSelectedValues();

                    Color[] colorScheme = colorCombo.getSelectedColors();

                    Color[] colors = new Color[colorScheme.length];

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

                        colors[i] = colorScheme[i];

                    }

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

                        getFieldsTable().addTableRecord(

                                colorScheme[rand.nextInt(colorScheme.length)],

                                (String) fields[i], (String) fields[i]);

                        ((DefaultListModel) getJFieldList().getModel())

                                .removeElement(fields[i]);

                    }

                }

            });

        }

        return addButton;

    }

    /**

     * This method initializes northPanel

     *

     * @return javax.swing.JPanel

     */

    private JPanel getNorthPanel() {

        if (northPanel == null) {

            lColorSchema = new JLabel();

            lColorSchema.setText(PluginServices.getText(this, "color_schema"));

            northPanel = new JPanel();

            northPanel.setLayout(new FlowLayout());

            northPanel.add(lColorSchema, null);

            northPanel.add(getColorCombo());

        }

        return northPanel;

    }

    private JComboBoxColorScheme getColorCombo() {

        if (colorCombo == null) {

            colorCombo = new JComboBoxColorScheme(false);

        }

        return colorCombo;

    }

    /**

     * This method initializes removeButton

     *

     * @return javax.swing.JButton

     */

    private JButton getRemoveButton() {

        if (removeButton == null) {

            removeButton = new JButton();

            removeButton.setPreferredSize(new Dimension(50, 40));

            removeButton.setText("<");

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

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

                    int[] index = getFieldsTable().getSelectedRows();

                    String[] fields = new String[index.length];

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

                        fields[i] = (String) getFieldsTable().getFieldValue(

                                index[i], 1);

                    }

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

                        ((DefaultListModel) getJFieldList().getModel())

                                .addElement(fields[i]);

                    }

                    getFieldsTable().removeSelectedRows();

                }

            });

        }

        return removeButton;

    }

    /**

     * This method initializes addAllButton

     *

     * @return javax.swing.JButton

     */

    private JButton getAddAllButton() {

        if (addAllButton == null) {

            addAllButton = new JButton();

            addAllButton.setPreferredSize(new Dimension(50, 40));

            addAllButton.setText(">>");

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

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

                    Object[] fields = ((DefaultListModel) getJFieldList()

                            .getModel()).toArray();

                    Color[] colorScheme = colorCombo.getSelectedColors();

                    Color[] colors = new Color[colorScheme.length];

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

                        colors[i] = colorScheme[i];

                    }

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

                        getFieldsTable().addTableRecord(

                                colorScheme[rand.nextInt(colorScheme.length)],

                                (String) fields[i], (String) fields[i]);

                        ((DefaultListModel) getJFieldList().getModel())

                                .removeElement(fields[i]);

                    }

                }

            });

        }

        return addAllButton;

    }

    /**

     * This method initializes removeAllButton

     *

     * @return javax.swing.JButton

     */

    private JButton getRemoveAllButton() {

        if (removeAllButton == null) {

            removeAllButton = new JButton();

            removeAllButton.setPreferredSize(new Dimension(50, 40));

            removeAllButton.setText("<<");

            removeAllButton

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

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

                            fillFieldNames();

                            getFieldsTable().removeAllItems();

                        }

                    });

        }

        return removeAllButton;

    }

    private void fillFieldNames() {

        FeatureStore rs;

        ((DefaultListModel) getJFieldList().getModel()).removeAllElements();

        try {

            rs = ((FLyrVect) layer).getFeatureStore();

            ArrayList<String> names = new ArrayList<String>();

            Iterator iterator = rs.getDefaultFeatureType().iterator();

            DefaultListModel cM = new DefaultListModel();

            while (iterator.hasNext()) {

                FeatureAttributeDescriptor descriptor = (FeatureAttributeDescriptor) iterator

                        .next();

                if (descriptor.getDataType().isNumeric()) {

                    names.add(descriptor.getName());

                    cM.addElement(descriptor.getName());

                }

            }

            getJFieldList().setModel(cM);

        } catch (DataException e) {

            NotificationManager.addError(

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

        }

    }

    private JPanel getButtons() {

        if (buttons == null) {

            FlowLayout flowLayout = new FlowLayout();

            flowLayout.setHgap(5);

            flowLayout.setAlignment(FlowLayout.CENTER);

            flowLayout.setVgap(1);

            buttons = new JPanel();

            buttons.setPreferredSize(new Dimension(60, 50));

            buttons.setLayout(flowLayout);

            buttons.add(getPCentral(), null);

        }

        return buttons;

    }

    private FieldsTable getFieldsTable() {

        if (fieldsTable == null) {

            fieldsTable = new FieldsTable();

            fieldsTable.setPreferredSize(new Dimension(250, 300));

            fieldsTable.addColorChange(new ColorChange() {

                public void actionChange() {

                    // actualizePreviewSymbol();

                }

            });

        }

        return fieldsTable;

    }

    private JScrollPane getJScrollPane() {

        if (jScrollPane == null) {

            jScrollPane = new JScrollPane();

            jScrollPane.setBorder(BorderFactory.createTitledBorder(null,

                    PluginServices.getText(this, "fields"),

                    TitledBorder.DEFAULT_JUSTIFICATION,

                    TitledBorder.DEFAULT_POSITION, new Font("Dialog",

                            Font.BOLD, 12), new Color(51, 51, 51)));

            jScrollPane.setPreferredSize(new Dimension(150, 150));

            jScrollPane.setViewportView(getJFieldList());

        }

        return jScrollPane;

    }

    /**

     * This method initializes jFieldList

     *

     * @return javax.swing.JList

     */

    private JList getJFieldList() {

        if (jFieldList == null) {

            DefaultListModel dlm = new DefaultListModel();

            jFieldList = new JList();

            jFieldList.setSize(new Dimension(150, 150));

            jFieldList.setModel(dlm);

        }

        return jFieldList;

    }

    public String getDescription() {

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

    }

    public ImageIcon getIcon() {

        return IconThemeHelper.getImageIcon("legend-pie-chart");

    }

    /*

         * (non-Javadoc)

         *

         * @see

         * org.gvsig.app.project.documents.view.legend.gui.ILegendPanel#getLegend()

     */

    public ILegend getLegend() {

        if (auxLegend == null) {

            auxLegend = (IChartLegend) MapContextLocator.getMapContextManager()

                    .createLegend(IChartLegend.PIECHART_LEGEND_NAME);

        }

        auxLegend.setOutlineShow(getJCheckBox().isSelected());

        auxLegend.setOutlineColor(getColorButton().getColor());

        auxLegend.setOutlineWidth(getComboWidth().getInteger());

        auxLegend.setIs3D(getCk3D().isSelected());

        if (getFieldsTable() != null) {

            int rowCount = getFieldsTable().getRowCount();

            if (rowCount > 0) {

                String[] fields = new String[rowCount];

                String[] labels = new String[rowCount];

                Color[] colors = new Color[rowCount];

                int[] types = new int[rowCount];

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

                    colors[i] = ((JPanel) getFieldsTable().getFieldValue(i, 0))

                            .getBackground();

                    fields[i] = (String) getFieldsTable().getFieldValue(i, 1);

                    labels[i] = (String) getFieldsTable().getFieldValue(i, 2);

                    //No es necesario para nada, pero si no lo inicializamos, peta el clonado de la leyenda (en AbstractClassifiedVectorLegend)

                    types[i] = DataTypes.STRING;

                }

                auxLegend.setClassifyingFieldNames(fields);

                //No es necesario para nada, pero si no lo inicializamos, peta el clonado de la leyenda (en AbstractClassifiedVectorLegend)

                auxLegend.setClassifyingFieldTypes(types);

                auxLegend.setFields(fields);

                auxLegend.setLabels(labels);

                auxLegend.setColors(colors);

                if (auxLegend.getSizeOption() == IChartSymbol.SIZEFIELD) {

                    int classifyingCount = fields.length + 2;

                    if (auxLegend.getFieldNormalize().equals("---")) {

                        classifyingCount = fields.length + 1;

                    }

                    String[] classifyingFields = new String[classifyingCount];

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

                        classifyingFields[i] = fields[i];

                    }

                    if (!auxLegend.getFieldNormalize().equals("---")) {

                        classifyingFields[classifyingCount - 2] = auxLegend

                                .getFieldNormalize();

                    }

                    classifyingFields[classifyingCount - 1] = auxLegend.getFieldSize();

                    auxLegend.setClassifyingFieldNames(classifyingFields);

                } else {

                    if (fields != null && fields.length > 0) {

                        auxLegend.setClassifyingFieldNames(fields);

                    }

                }

                double min = Double.MAX_VALUE;

                double max = Double.MIN_VALUE;

                if (auxLegend.getSizeOption() == IChartSymbol.SIZEFIELD) {

                    try {

                        FeatureStore fs = layer.getFeatureStore();

                        FeatureType ft = fs.getDefaultFeatureType();

                        FeatureAttributeDescriptor[] atts = ft

                                .getAttributeDescriptors();

                        ArrayList<String> auxNames = new ArrayList<String>();

                        FeatureSet fset = fs.getFeatureSet();

                        DisposableIterator it = fset.fastIterator();

                        long rows = fs.getFeatureCount();

                        int index = ft.getAttributeDescriptor(auxLegend.getFieldSize())

                                .getIndex();

                        while (it.hasNext()) {

                            Feature f = (Feature) it.next();

                            double dob = f.getDouble(index);

                            if (dob < min) {

                                min = dob;

                            }

                            if (dob > max) {

                                max = dob;

                            }

                        }

                        it.dispose();

                        auxLegend.setMinFeature(min);

                        auxLegend.setMaxFeature(max);

                    } catch (DataException e) {

                        // TODO Auto-generated catch block

                        e.printStackTrace();

                    }

                } else if (auxLegend.getSizeOption() == IChartSymbol.SIZESUM) {

                    try {

                        FeatureStore fs = layer.getFeatureStore();

                        FeatureType ft = fs.getDefaultFeatureType();

                        FeatureAttributeDescriptor[] atts = ft

                                .getAttributeDescriptors();

                        ArrayList<String> auxNames = new ArrayList<String>();

                        FeatureSet fset = fs.getFeatureSet();

                        DisposableIterator it = fset.fastIterator();

                        long rows = fs.getFeatureCount();

                        String[] names = auxLegend.getClassifyingFieldNames();

                        int[] indexes = new int[names.length];

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

                            indexes[i] = ft.getAttributeDescriptor(names[i]).getIndex();

                        }

                        while (it.hasNext()) {

                            Feature f = (Feature) it.next();

                            double dob = 0;

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

                                dob += f.getDouble(indexes[i]);

                            }

                            if (dob < min) {

                                min = dob;

                            }

                            if (dob > max) {

                                max = dob;

                            }

                        }

                        it.dispose();

                        auxLegend.setMinFeature(min);

                        auxLegend.setMaxFeature(max);

                    } catch (DataException e) {

                        // TODO Auto-generated catch block

                        e.printStackTrace();

                    }

                }// ////////////////////////////////////////////

                auxLegend.useDefaultSymbol(true);

                // TODO: DEVOLVER LA LEYENDA CORRECTA!!!

                // TODO: ESTO HAY QUE HACERLO BIEN. LA IDEA ES GENERAR CORRECTAMENTE

                // EL CHARTDATASET, PERO NO CON LOS REQUIREDFIELDS.

                // Ahora los campos son como las filas con las que trabajabamos

                // antes.

                IChartSymbol symbol = (IChartSymbol) MapContextLocator

                        .getSymbolManager().createSymbol(IChartSymbol.SYMBOL_NAME);

                ChartManager cm = ChartLocator.getServiceManager().getChartManager();

                ChartProperties props;

                try {

                    props = cm.createProperties("PieChart");

                    if (auxLegend.is3D()) {

                        props.setChartDimension(true);

                        props.setChartRenderer("PieChartRenderer3DBasic");

                    } else {

                        props.setChartDimension(false);

                        props.setChartRenderer("PieChartRendererBasic");

                    }

                    auxLegend.setColors(colors);

                    props.setHasPlotOutline(auxLegend.isOutlineShow());

                    props.setIsLegendVisible(false);

                    props.setPlotBackgroundColor(auxLegend.getOutlineColor());

                    if (getJCheckBox().isSelected()) {

                        float alpha = colorButton.getAlpha() / 100;

                        if (alpha > 1) {

                            props.setPlotBackgroundAlpha(1.0f);

                        } else {

                            props.setPlotBackgroundAlpha(alpha);

                        }

                    } else {

                        props.setPlotBackgroundAlpha(0.0f);

                    }

                    props.setChartName("");

                    props.setChartDimension(auxLegend.is3D());

                    ChartService cs = cm.createChart(props);

                    cs.setIsAChartSymbol(true);

                    // Fijamos los colores dentro del ChartSymbol para hacerlo solo una vez

                    if (cs.getRenderer() != null) {

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

                            cs.getRenderer().setSeriesPaint(i, auxLegend.getColors()[i]);

                        }

                    }

                    // TODO: REVISAR QU? PASA CUANDO HAY SELECCION. EL SIMBOLO QUE DEVUELVE NO ES CORRECTO

                    symbol.setChart(cs);

                    auxLegend.setDefaultSymbol(symbol);

                } catch (ServiceException e) {

                    // TODO Auto-generated catch block

                    e.printStackTrace();

                }

            }

        }

        this.theLegend = auxLegend;

        return theLegend;

    }

    public Class getLegendClass() {

        return PieChartLegend.class;

    }

    public JPanel getPanel() {

        return this;

    }

    public Class getParentClass() {

        return MultipleAttributes.class;

    }

    public String getTitle() {

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

    }

    public boolean isSuitableFor(FLayer layer) {

        return (layer instanceof FLyrVect);

    }

    public void setData(FLayer layer, ILegend legend) {

        this.layer = (FLyrVect) layer;

        try {

            shapeType = this.layer.getShapeType();

        } catch (ReadException e) {

            e.printStackTrace();

        }

        //getBackgroundSymbol().setShapeType(shapeType);

        fieldsTable = getFieldsTable();

        fieldsTable.setSize(new Dimension(235, 129));

        fillFieldNames();

        fieldsTable.removeAllItems();

        if (legend instanceof IPieChartLegend) {

            IPieChartLegend pieChartLegend = (IPieChartLegend) legend;

            // TODO: PROVISIONAL. CREAMOS SIEMPRE LA LEYENDA PORQUE NO LA PODEMOS CLONAR TODAVIA.

            // auxLegend = (IChartLegend) legend.cloneLegend();

            getJCheckBox().setSelected(pieChartLegend.isOutlineShow());

            getColorButton().setColor(pieChartLegend.getOutlineColor());

            getComboWidth().setInteger(pieChartLegend.getOutlineWidth());

            getCk3D().setSelected(pieChartLegend.is3D());

            getCkOnlySelection().setSelected(pieChartLegend.isOnlySelection());

            String[] fields;

            String[] labels;

            fields = pieChartLegend.getClassifyingFieldNames();

            labels = pieChartLegend.getFieldLabels();

            if (fields != null) {

                if (labels != null && labels.length != fields.length) {

                    String[] aux = new String[fields.length];

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

                        aux[i] = fields[i];

                    }

                    labels = aux;

                }

                Color[] colors = new Color[fields.length];

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

                    colors[i] = ((IPieChartLegend) legend).getSymbolByValue(fields[i]).getColor();

                }

                if (colors != null) {

                    getFieldsTable().fillTableFromSymbolList(colors, fields, labels);

                    // getPreviewChart().setSections(fields, colors);

                }

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

                    ((DefaultListModel) getJFieldList().getModel()).removeElement(fields[i]);

                }

            }

        }

    }

    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;

        }

    }

    /**

     * This method initializes ckOnlySelection

     *

     * @return javax.swing.JCheckBox

     */

    private JCheckBox getCkOnlySelection() {

        if (ckOnlySelection == null) {

            ckOnlySelection = new JCheckBox();

            ckOnlySelection.setText(PluginServices.getText(this,

                    "only_selection"));

        }

        return ckOnlySelection;

    }

} // @jve:decl-index=0:visual-constraint="10,10"