| gvSIG desktop 1

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

 *

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

 *

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

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

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

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

 *

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

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

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

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

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

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

 *

 * For more information, contact:

 *

 *  Generalitat Valenciana

 *   Conselleria d'Infraestructures i Transport

 *   Av. Blasco Ib��ez, 50

 *   46010 VALENCIA

 *   SPAIN

 *

 *      +34 963862235

 *   gvsig@gva.es

 *      www.gvsig.gva.es

 *

 *    or

 *

 *   IVER T.I. S.A

 *   Salamanca 50

 *   46005 Valencia

 *   Spain

 *

 *   +34 963163400

 *   dac@iver.es

 */

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

import java.awt.BorderLayout;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.io.File;

import java.io.IOException;

import java.util.ArrayList;

import javax.swing.ImageIcon;

import javax.swing.JCheckBox;

import javax.swing.JOptionPane;

import javax.swing.JPanel;

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

import org.gvsig.symbology.fmap.rendering.VectorialFilterExpressionLegend;

import org.gvsig.symbology.fmap.symbols.PictureFillSymbol;

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

import com.iver.andami.PluginServices;

import com.iver.andami.messages.NotificationManager;

import com.iver.andami.ui.mdiManager.IWindow;

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

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

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

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

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

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

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

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

/**

 * Implements the JPanel that shows the properties of a VectorialFilterExpressionLegend

 * in order to allows the user to modify its characteristics

 * 

 * @author Pepe Vidal Salvador - jose.vidal.salvador@iver.es

 *

 */

public class VectorialFilterExpression extends JPanel implements ILegendPanel,ActionListener {

        private static final long serialVersionUID = -7187473609965942511L;

        private VectorialFilterExpressionLegend theLegend;

        private ClassifiableVectorial layer;

        private PictureFillSymbol previewSymbol;

        private JPanel pnlCenter;

        private SymbolTable symbolTable;

        private JButton btnAddExpression;

        private JButton btnModExpression;

        private JButton btnRemoveExpression;

        private JCheckBox useDefaultSymbol;

        private int shapeType;

        /**

         * This is the default constructor

         */

        public VectorialFilterExpression() {

                super();

                initialize();

        }

        /**

         * This method initializes this

         */

        private void initialize() {

                pnlCenter = new JPanel();

                pnlCenter.setLayout(new BorderLayout());

                JPanel pnlButtons = new JPanel();

                useDefaultSymbol = new JCheckBox(PluginServices.getText(this, "use_default_symbol"));

                useDefaultSymbol.setActionCommand("USE_DEFAULT_SYMBOL");

                useDefaultSymbol.addActionListener(this);

                pnlButtons.add(useDefaultSymbol);

                btnAddExpression = new JButton(PluginServices.getText(this, "new_filter_expression"));

                btnAddExpression.setActionCommand("NEW_EXPRESSION");

                btnAddExpression.addActionListener(this);

                pnlButtons.add(btnAddExpression);

                btnModExpression = new JButton(PluginServices.getText(this, "modify_filter_expression"));

                btnModExpression.setActionCommand("MODIFY_EXPRESSION");

                btnModExpression.addActionListener(this);

                pnlButtons.add(btnModExpression);

                btnRemoveExpression = new JButton(PluginServices.getText(this, "delete_filter_expression"));

                btnRemoveExpression.setActionCommand("REMOVE");

                btnRemoveExpression.addActionListener(this);

                pnlButtons.add(btnRemoveExpression);

                this.setLayout(new BorderLayout());

                this.add(pnlCenter, BorderLayout.CENTER);

                this.add(pnlButtons, BorderLayout.SOUTH);

        }

        public String getDescription() {

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

        }

        public ISymbol getIconSymbol() {

                if (previewSymbol == null) {

                        try {

                                previewSymbol = new PictureFillSymbol();

                                previewSymbol.setImage( new File(

                                                this.getClass().getClassLoader().

                                                getResource("images/ValoresUnicos.png").

                                                getFile()).toURL());

                                previewSymbol.getMarkerFillProperties().

                                setFillStyle(

                                                IMarkerFillPropertiesStyle.SINGLE_CENTERED_SYMBOL);

                        } catch (IOException e) {

                                return null;

                        }

                }

                return previewSymbol;

        }

        public ILegend getLegend() {

                theLegend.clear();

                fillSymbolListFromTable();

                return theLegend;

        }

        /**

         * Fills the list of symbols of the legend

         *

         */

        private void fillSymbolListFromTable() {

                Object clave;

                ISymbol theSymbol;

                boolean bRestoValores = false;

                int hasta;

                FLyrVect m = (FLyrVect) layer;

                try {

                        if(theLegend.getClassifyingFieldNames() != null) {

                                String[] fNames= theLegend.getClassifyingFieldNames();

                                int[] fieldTypes  = new int[theLegend.getClassifyingFieldNames().length];

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

                                        int fieldIndex = m.getSource().getRecordset().getFieldIndexByName(fNames[i]);

                                        fieldTypes[i]= m.getSource().getRecordset().getFieldType(fieldIndex);

                                }

                                theLegend.setClassifyingFieldTypes(fieldTypes);

                        }

                } catch (ReadDriverException e) {

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

                }

                if (bRestoValores) {

                        hasta = symbolTable.getRowCount() - 1;

                } else {

                        hasta = symbolTable.getRowCount();

                }

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

                        clave =  symbolTable.getFieldValue(row, 1);

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

                        theSymbol.setDescription((String) symbolTable.getFieldValue(row, 2));

                        theLegend.addSymbol(clave, theSymbol);

                }

                if (bRestoValores) {

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

                        theLegend.setDefaultSymbol(theSymbol);

                }

        }

        public Class getLegendClass() {

                return VectorialFilterExpressionLegend.class;

        }

        public JPanel getPanel() {

                return this;

        }

        public Class getParentClass() {

                return Categories.class;

        }

        public String getTitle() {

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

        }

        public boolean isSuitableFor(FLayer layer) {

                FLyrVect lVect = (FLyrVect) layer;

                try {

                        return lVect.getShapeType() != FShape.MULTI;

                } catch (ReadDriverException e) {

                        return false;

                }

        }

        public void setData(FLayer lyr, ILegend legend) {

                this.layer = (ClassifiableVectorial) lyr;

                shapeType = 0;

                try {

                        shapeType = this.layer.getShapeType();

                } catch (ReadDriverException e) {

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

                }

                if (symbolTable != null)

                        pnlCenter.remove(symbolTable);

                symbolTable = new SymbolTable(this, "expressions", shapeType);

                pnlCenter.add(symbolTable, BorderLayout.CENTER);

                if (legend instanceof VectorialFilterExpressionLegend) {

                        theLegend = (VectorialFilterExpressionLegend) legend;

                        symbolTable.fillTableFromSymbolList(theLegend.getSymbols(),

                                        theLegend.getValues(), theLegend.getDescriptions());

                        useDefaultSymbol.setSelected(theLegend.isUseDefaultSymbol());

                } else {

                        theLegend = new VectorialFilterExpressionLegend();

                        theLegend.setShapeType(shapeType);

                        useDefaultSymbol.setSelected(false);

                        theLegend.useDefaultSymbol(useDefaultSymbol.isSelected());

                }

        }

        public void actionPerformed(ActionEvent e) {

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

                        ExpressionCreator newExpression = new ExpressionCreator((FLyrVect) this.layer );

                        PluginServices.getMDIManager().addWindow((IWindow) newExpression);

                        String expression = ((ExpressionCreator) newExpression).getExpression();

                        if(newExpression.getFieldNamesExpression() != null)

                                addClassFieldNames(newExpression.getFieldNamesExpression());

                        if(expression != null)

                                if(expression.compareTo("") != 0) {

                                        symbolTable.addTableRecord(newExpression.getSymbolForExpression(), expression, newExpression.getDescriptionForExpression());

                                        theLegend.addSymbol(expression, newExpression.getSymbolForExpression());

                                }

                        repaint();

                }

                else if (e.getActionCommand() == "MODIFY_EXPRESSION") {

                        if(symbolTable.getSelectedRowElements() == null) {

                                JOptionPane.showMessageDialog(this, PluginServices.getText(this, "select_one_row")+".\n");

                        }

                        else {

                                ISymbol mySymbol = (ISymbol) symbolTable.getSelectedRowElements()[0];

                                String expression = (String) symbolTable.getSelectedRowElements()[1];

                                String myDesc = (String) symbolTable.getSelectedRowElements()[2];

                                ExpressionCreator newExpression = new ExpressionCreator((FLyrVect) this.layer );

                                newExpression.setExpression(expression);

                                newExpression.setDescriptionForExpression(myDesc);

                                newExpression.setSymbolForExpression(mySymbol);

                                PluginServices.getMDIManager().addWindow((IWindow) newExpression);

                                expression = ((ExpressionCreator) newExpression).getExpression();

                                if(expression != null)

                                        if(expression.compareTo("") != 0) {

                                                symbolTable.removeSelectedRows();

                                                theLegend.delSymbol(expression);

                                                symbolTable.addTableRecord(newExpression.getSymbolForExpression(), ((ExpressionCreator) newExpression).getExpression(), newExpression.getDescriptionForExpression());

                                                theLegend.addSymbol(((ExpressionCreator) newExpression).getExpression(), newExpression.getSymbolForExpression());

                                                repaint();

                                        }

                        }

                }

                else if (e.getActionCommand() == "USE_DEFAULT_SYMBOL" ) {

                        if(theLegend != null) {

                                theLegend.useDefaultSymbol(useDefaultSymbol.isSelected());

                                repaint();

                        }

                }

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

                        if(symbolTable.getSelectedRowElements() == null) {

                                JOptionPane.showMessageDialog(this, PluginServices.getText(this, "select_one_row")+".\n");

                        }

                        else 

                                symbolTable.removeSelectedRows();

                }        

        }

        /**

         * Adds new classifying field names to the legend when a new expression is 

         * created or an existing one is modified

         * @param fieldNamesExpression

         */

        private void addClassFieldNames(Object[] fieldNamesExpression) {

                boolean appears = false;

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

                if (theLegend.getClassifyingFieldNames() != null) {

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

                                myFieldNames.add(theLegend.getClassifyingFieldNames()[i]);

                        }

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

                                appears = false;

                                for (int j = 0; j < theLegend.getClassifyingFieldNames().length; j++) {

                                        if (theLegend.getClassifyingFieldNames()[j].compareTo((String) fieldNamesExpression[i]) == 0)

                                                appears = true;

                                }

                                if(!appears) {

                                        myFieldNames.add((String) fieldNamesExpression[i]);

                                }

                        }

                        theLegend.setClassifyingFieldNames((String[])myFieldNames.toArray(new

                                        String[myFieldNames.size()]));

                }

                else {

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

                                myFieldNames.add((String) fieldNamesExpression[i]);

                        }

                        theLegend.setClassifyingFieldNames((String[])myFieldNames.toArray(new

                                        String[myFieldNames.size()]));

                }

        }

        public ImageIcon getIcon() {

                // TODO Auto-generated method stub

                return null;

        }

}