Application: gvSIG desktop

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

 *

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

 *

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

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

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

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

 *

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

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

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

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

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

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

 *

 * For more information, contact:

 *

 *  Generalitat Valenciana

 *   Conselleria d'Infraestructures i Transport

 *   Av. Blasco Ib??ez, 50

 *   46010 VALENCIA

 *   SPAIN

 *

 *      +34 963862235

 *   gvsig@gva.es

 *      www.gvsig.gva.es

 *

 *    or

 *

 *   IVER T.I. S.A

 *   Salamanca 50

 *   46005 Valencia

 *   Spain

 *

 *   +34 963163400

 *   dac@iver.es

 */

/* CVS MESSAGES:

*

* $Id: GraduatedSymbols.java 10315 2007-02-14 09:59:17Z jaume $

* $Log$

* Revision 1.1.2.3  2007-02-14 09:59:17  jaume

* *** empty log message ***

*

* Revision 1.1.2.2  2007/02/13 16:19:19  jaume

* graduated symbol legends (start commiting)

*

* Revision 1.1.2.1  2007/02/12 15:14:41  jaume

* refactored interval legend and added graduated symbol legend

*

*

*/

package com.iver.cit.gvsig.project.documents.view.legend.gui;

import java.awt.Color;

import java.awt.Dimension;

import java.awt.FlowLayout;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.text.NumberFormat;

import javax.swing.BorderFactory;

import javax.swing.JLabel;

import javax.swing.JOptionPane;

import javax.swing.JPanel;

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

import com.iver.andami.PluginServices;

import com.iver.andami.messages.NotificationManager;

import com.iver.cit.gvsig.fmap.DriverException;

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

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

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

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.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.rendering.FInterval;

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

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

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

import com.iver.cit.gvsig.gui.styling.SymbolSelector;

import de.ios.framework.swing.JNumberField;

public class GraduatedSymbols extends VectorialInterval implements ILegendPanel {

        private JNumberField txtMinSize;

        private JNumberField txtMaxSize;

        private ISymbol templateSymbol;

        private JSymbolPreviewButton btnTemplate;

        private int shapeType;

        public JPanel getOptionPanel() {

            if (optionPanel == null) {

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

                optionPanel.setBorder(BorderFactory.

                            createTitledBorder(null,

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

                GridBagLayoutPanel aux = new GridBagLayoutPanel();

                aux.addComponent(new JLabel(PluginServices.getText(this, "size")));

                aux.addComponent(PluginServices.getText(this, "from")+":",

                    getTxtMinSize());

                aux.addComponent(PluginServices.getText(this, "to")+":",

                    getTxtMaxSize());

                aux.addComponent(PluginServices.getText(this, "template"), getBtnTemplate());

                optionPanel.add(aux);

        }

        return optionPanel;

        }

        private JSymbolPreviewButton getBtnTemplate() {

                if (btnTemplate == null) {

                        btnTemplate = new JSymbolPreviewButton();

                        btnTemplate.addActionListener(new ActionListener() {

                                public void actionPerformed(ActionEvent e) {

                                        SymbolSelector sSelect = new SymbolSelector(templateSymbol, shapeType);

                                        PluginServices.getMDIManager().addWindow(sSelect);

                                        templateSymbol = sSelect.getSymbol();

                                        btnTemplate.setSymbol(templateSymbol);

                                }

                        });

                        btnTemplate.setPreferredSize(new Dimension(100, 35));

                }

                return btnTemplate;

        }

        private JNumberField getTxtMaxSize() {

                if (txtMaxSize == null) {

                        txtMaxSize = new JNumberField();

                }

                return txtMaxSize;

        }

        private JNumberField getTxtMinSize() {

                if (txtMinSize == null) {

                        txtMinSize = new JNumberField();

                }

                return txtMinSize;

        }

        public void setData(FLayer lyr, Legend legend) {

                this.layer = (FLyrVect) lyr;

            try {

                    setShapeType(this.layer.getShapeType());

            } catch (DriverException 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 GraduatedSymbolLegend) {

                renderer = (GraduatedSymbolLegend) legend;

                GraduatedSymbolLegend theRenderer = (GraduatedSymbolLegend) legend;

                getChkDefaultvalues().setSelected(theRenderer.isUseDefaultSymbol());

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

            symbolTable.fillTableFromSymbolList(theRenderer.getSymbols(),

                theRenderer.getValues(), theRenderer.getDescriptions());

            getTxtMaxSize().setText(

                            String.valueOf(theRenderer.getMaxSymbolSize()));

            getTxtMinSize().setText(

                            String.valueOf(theRenderer.getMinSymbolSize()));

        } else {

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

                // una nueva del tipo que maneja este panel

                renderer = new GraduatedSymbolLegend();

        }

        cmbFieldType.setSelectedIndex(renderer.getIntervalType());

        }

        /**

         * Polygon type does not have any sense in this context, it is considered

         * as Marker type. Lines are lines, and markers ar markers.

         * @param shapeType

         */

        private void setShapeType(int shapeType) {

                switch (shapeType) {

                case FShape.POINT:

                case FShape.POLYGON:

                        this.shapeType = FShape.POINT;

                        break;

                case FShape.LINE:

                        this.shapeType = FShape.LINE;

                        break;

                default:

                        throw new Error("Unknown symbol type");

                }

        }

        public String getDescription() {

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

        }

        public Legend getLegend() {

                GraduatedSymbolLegend l = (GraduatedSymbolLegend) super.getLegend();

                l.setMinSymbolSize(getTxtMinSize().getValue().doubleValue());

                l.setMaxSymbolSize(getTxtMaxSize().getValue().doubleValue());

                l.setDefaultSymbol(templateSymbol);

                return l;

        }

        public ISymbol getPreviewSymbol() {

                // TODO Implement it

                return null;

        }

        public Class getParentClass() {

                return Quantities.class;

        }

        public String getTitle() {

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

        }

        public JPanel getPanel() {

                return this;

        }

        public Class getLegendClass() {

                return GraduatedSymbolLegend.class;

        }

        private ISymbol newSymbol(int shapeType, double size) {

                if (templateSymbol == null) {

                        switch (shapeType) {

                        case FShape.POINT:

                        case FShape.POLYGON:

                                templateSymbol = new SimpleMarkerSymbol();

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

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

                                break;

                        case FShape.LINE:

                                templateSymbol = new SimpleLineSymbol();

                                ((SimpleLineSymbol) templateSymbol).setWidth(size);

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

                                break;

                        default:

                                throw new Error("Unknown symbol type");

                        }

                        return newSymbol(shapeType, size);

                } else {

                        // clone symbol

                        ISymbol mySymbol = SymbologyFactory.createSymbolFromXML(templateSymbol.getXMLEntity(), null);

                        if (mySymbol instanceof ILineSymbol) {

                                ILineSymbol lSym = (ILineSymbol) templateSymbol;

                                lSym.setWidth(size);

                        }

                        if (mySymbol instanceof IMarkerSymbol) {

                                IMarkerSymbol mSym = (IMarkerSymbol) templateSymbol;

                                mSym.setSize(size);

                        }

                        return mySymbol;

                }

        }

        /**

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

                try {

                        symbolTable.removeAllItems();

                        FInterval[] arrayIntervalos = calculateIntervals();

                        if (arrayIntervalos == null)

                                return;

                        FInterval interval;

                        NumberFormat.getInstance().setMaximumFractionDigits(2);

                        renderer.clear();

                        float minSize = getTxtMinSize().getValue().floatValue();

                        float maxSize = getTxtMaxSize().getValue().floatValue();

                        ISymbol theSymbol;

                        if (chkdefaultvalues.isSelected()) {

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

                                auxLegend.addSymbol(new NullIntervalValue(),

                                                auxLegend.getDefaultSymbol());

                        }

                        int symbolType;

                        symbolType = layer.getShapeType();

                        int numSymbols = 0;

                        double step = (maxSize - minSize) / arrayIntervalos.length;

                        double size = minSize;

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

                                interval = arrayIntervalos[k];

                                theSymbol = newSymbol(symbolType, size);

                                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;

                                        }

                                }

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

                                                " - " +

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

                                size = size + step;

                        } // for

                        symbolTable.fillTableFromSymbolList(auxLegend.getSymbols(),

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

                } catch (DriverException e) {

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

                }

                bDelAll.setEnabled(true);

                bDel.setEnabled(true);

        }

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