| gvSIG desktop 1

/* 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 11704 2007-05-17 09:43:35Z jaume $

* $Log$

* Revision 1.6  2007-05-17 09:32:37  jaume

* *** empty log message ***

*

* Revision 1.5  2007/05/10 09:46:45  jaume

* Refactored legend interface names

*

* Revision 1.4  2007/05/08 15:45:31  jaume

* *** empty log message ***

*

* Revision 1.3  2007/03/21 08:03:03  jaume

* refactored to use ISymbol instead of FSymbol

*

* Revision 1.2  2007/03/09 11:25:00  jaume

* Advanced symbology (start committing)

*

* Revision 1.1.2.4  2007/02/21 07:35:14  jaume

* *** empty log message ***

*

* 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.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.hardcode.gdbms.driver.exceptions.ReadDriverException;

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

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

import com.iver.cit.gvsig.gui.IncrementalNumberField;

public class GraduatedSymbols extends VectorialInterval implements ILegendPanel {

        private IncrementalNumberField txtMinSize;

        private IncrementalNumberField txtMaxSize;

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

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

                }

                return btnTemplate;

        }

        private IncrementalNumberField getTxtMaxSize() {

                if (txtMaxSize == null) {

                        txtMaxSize = new IncrementalNumberField(String.valueOf(25), 7);

                }

                return txtMaxSize;

        }

        private IncrementalNumberField getTxtMinSize() {

                if (txtMinSize == null) {

                        txtMinSize = new IncrementalNumberField(String.valueOf(3), 7);

                }

                return txtMinSize;

        }

        public void setData(FLayer lyr, ILegend legend) {

                this.layer = (FLyrVect) lyr;

            try {

                    setShapeType(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 GraduatedSymbolLegend) {

                renderer = (GraduatedSymbolLegend) legend;

                GraduatedSymbolLegend theRenderer = (GraduatedSymbolLegend) legend;

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

            cmbField.setSelectedItem(theRenderer.getFieldNames()[0]);

            symbolTable.fillTableFromSymbolList(theRenderer.getSymbols(),

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

            getTxtMaxSize().setDouble(theRenderer.getMaxSymbolSize());

            getTxtMinSize().setDouble(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");

                }

                getBtnTemplate().setShapeType(this.shapeType);

        }

        public String getDescription() {

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

        }

        public ILegend getLegend() {

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

                l.setMinSymbolSize(getTxtMinSize().getDouble());

                l.setMaxSymbolSize(getTxtMaxSize().getDouble());

                l.setDefaultSymbol(getBtnTemplate().getSymbol());

                try {

                        l.setShapeType(layer.getShapeType());

                } catch (ReadDriverException e) {

                        // TODO Auto-generated catch block

                        NotificationManager.addWarning("Reached what should be unreachable code", e);

                }

                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 (getBtnTemplate().getSymbol() == null) {

                        ISymbol templateSymbol;

                        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).setLineWidth(size);

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

                                break;

                        default:

                                throw new Error("Unknown symbol type");

                        }

                        getBtnTemplate().setSymbol(templateSymbol);

                        return newSymbol(shapeType, size);

                } else {

                        // clone symbol

                        ISymbol mySymbol = SymbologyFactory.createSymbolFromXML(

                                        getBtnTemplate().getSymbol().getXMLEntity(), null);

                        if (mySymbol instanceof ILineSymbol) {

                                ILineSymbol lSym = (ILineSymbol) mySymbol;

                                lSym.setLineWidth(size);

                        }

                        if (mySymbol instanceof IMarkerSymbol) {

                                IMarkerSymbol mSym = (IMarkerSymbol) mySymbol;

                                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 = (float) getTxtMinSize().getDouble();

                        float maxSize = (float) getTxtMaxSize().getDouble();

                        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 (ReadDriverException 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"