| 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

 */

package org.gvsig.symbology.gui.layerproperties;

import java.awt.BorderLayout;

import java.awt.Color;

import java.awt.Dimension;

import java.awt.FlowLayout;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.sql.Types;

import javax.swing.BorderFactory;

import javax.swing.DefaultComboBoxModel;

import javax.swing.ImageIcon;

import javax.swing.JComboBox;

import javax.swing.JLabel;

import javax.swing.JPanel;

import org.apache.log4j.Logger;

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

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

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

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

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

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

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

import com.hardcode.gdbms.engine.values.Value;

import com.hardcode.gdbms.engine.values.ValueFactory;

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.styles.IMarkerFillPropertiesStyle;

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.layers.SelectableDataSource;

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

import com.iver.cit.gvsig.project.documents.view.legend.gui.ILegendPanel;

import com.iver.cit.gvsig.project.documents.view.legend.gui.JSymbolPreviewButton;

import com.iver.cit.gvsig.project.documents.view.legend.gui.Quantities;

/**

 * Implements the panel for the legend of proportional symbols.In the interface will be

 * options to select the value field, the normalization field (if the user wants to use it) and

 * options to select the symbol an its minimum and maximum size.

 *

 * Also there will be possible to select a background symbol (only when the shapetype of the layer is

 * polygonal).

 *

 * @author jaume dominguez faus - jaume.dominguez@iver.es

 */

public class ProportionalSymbols extends JPanel implements ILegendPanel{

	private static final long serialVersionUID = 7394720230276170902L;

	private JPanel symbolPanel;

	private JPanel backgroundPanel;

	private JSymbolPreviewButton tmplateSymbol;

	private JSymbolPreviewButton backSymbol;

	private JComboBox cmbValue;

	private JComboBox cmbNormalization;

	private JIncrementalNumberField txtMinSize;

	private JIncrementalNumberField txtMaxSize;

	private static Logger logger = Logger.getLogger(ProportionalSymbols.class.getName());

	private ClassifiableVectorial myLayer;

	private ProportionalSymbolsLegend auxLegend;

	private ProportionalSymbolsLegend theLegend;

	private String[] fieldNames;

	private int templateShapeType = 0 ;

	private String noNormalization = PluginServices.getText(this, "none");

	private boolean useNormalization = true;

	/**

	 * Default constructor

	 */

	public ProportionalSymbols() {

		initialize();

	}

	/**

	 * This method initializes this

	 */

	private void initialize() {

		setLayout(new BorderLayout());

		JPanel aux = new JPanel(new BorderLayout());

		JPanel fieldsPanel = new JPanel(new FlowLayout());

		fieldsPanel.setBorder(BorderFactory.

				createTitledBorder(null,

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

		fieldsPanel.setPreferredSize(new Dimension(300,60));

		cmbValue = new JComboBox();

		cmbValue.setActionCommand("VALUE_SELECTED");

		cmbNormalization = new JComboBox();

		cmbNormalization.setActionCommand("NORMALIZATION_SELECTED");

		fieldsPanel.add(new JLabel(PluginServices.getText(this, "value")+":" ));

		fieldsPanel.add(cmbValue);

		fieldsPanel.add(new JLabel(PluginServices.getText(this, "normalization")+":" ));

		fieldsPanel.add(cmbNormalization);

		symbolPanel = new JPanel(new FlowLayout(FlowLayout.LEADING, 3,2));

		symbolPanel.setBorder(BorderFactory.

				createTitledBorder(null,

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

		GridBagLayoutPanel aux2 = new GridBagLayoutPanel();

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

		aux2.addComponent(new JBlank(10,10));

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

				getTxtMinSize());

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

				getTxtMaxSize());

		JPanel templatePanel = new JPanel();

		templatePanel.setBorder(BorderFactory.createTitledBorder(null,

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

		templatePanel.add(getTemplSymbol());

		symbolPanel.add(new JBlank(10,10));

		symbolPanel.add(aux2);

		symbolPanel.add(new JBlank(10,10));

		symbolPanel.add(templatePanel);

		aux.add(fieldsPanel, BorderLayout.NORTH);

		aux.add(symbolPanel, BorderLayout.CENTER);

		this.add(aux, BorderLayout.CENTER);

		cmbValue.addActionListener(action);

		cmbNormalization.addActionListener(action);

		tmplateSymbol.addActionListener(action);

	}

	/**

	 * Creates the panel where the button for the background symbol will be placed

	 *

	 * @return JPanel panel

	 */

	private JPanel getBackgroundPanel() {

		backgroundPanel = new JPanel();

		backgroundPanel.setBorder(BorderFactory.createTitledBorder(null,

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

		backgroundPanel.add(getBtnBackground());

		return backgroundPanel;

	}

	/**

	 * Creates a JIncrementalNumberField which is used to select the maximum size for the symbol

	 *

	 * @return JIncrementalNumberField

	 */

	private JIncrementalNumberField getTxtMaxSize() {

		if (txtMaxSize == null) {

			txtMaxSize = new JIncrementalNumberField(String.valueOf(25), 7,0,100,1);

			txtMaxSize.addActionListener(action);

		}

		return txtMaxSize;

	}

	/**

	 * Creates a JIncrementalNumberField which is used to select the minimum size for the symbol

	 *

	 * @return JIncrementalNumberField

	 */

	private JIncrementalNumberField getTxtMinSize() {

		if (txtMinSize == null) {

			txtMinSize = new JIncrementalNumberField(String.valueOf(3), 7,0,100,1);

			txtMinSize.addActionListener(action);

		}

		return txtMinSize;

	}

	/**

	 * Creates a JSymbolPreviewButton which is used to select the template symbol

	 *

	 * @return JSymbolPreviewButton

	 */

	private JSymbolPreviewButton getTemplSymbol() {

		if (tmplateSymbol == null) {

			int templateShapeType = (this.templateShapeType == FShape.POLYGON) ? FShape.POINT : this.templateShapeType;

			tmplateSymbol = new JSymbolPreviewButton(templateShapeType);

		}

		tmplateSymbol.setPreferredSize(new Dimension(100, 45));

		return tmplateSymbol;

	}

	/**

	 * Creates a JSymbolPreviewButton which is used to select the background symbol

	 *

	 * @return JSymbolPreviewButton

	 */

	private JSymbolPreviewButton getBtnBackground() {

		if (backSymbol == null) {

			backSymbol = new JSymbolPreviewButton(FShape.POLYGON);

			backSymbol.setPreferredSize(new Dimension(100, 45));

		}

		return backSymbol;

	}

	/**

	 * Creates a new symbol of an specific shapetype with a concrete size

	 *

	 * @param shapeType

	 * @param size

	 *

	 * @return ISymbol symbol created

	 */

	private ISymbol newSymbol(int shapeType, double size) {

		if (getTemplSymbol().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");

			}

			getTemplSymbol().setSymbol(templateSymbol);

			return newSymbol(shapeType, size);

		} else {

			// clone symbol

			ISymbol mySymbol = SymbologyFactory.createSymbolFromXML(

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

				if (shapeType == FShape.POLYGON) {

					// this is to allow using in Polygon layers

					MarkerFillSymbol fillSymbol = new MarkerFillSymbol();

					fillSymbol.setOutline(null);

					fillSymbol.setFillColor(null);

					fillSymbol.getMarkerFillProperties().

					setFillStyle(IMarkerFillPropertiesStyle.SINGLE_CENTERED_SYMBOL);

					fillSymbol.setMarker(mSym);

				}

			}

			return mySymbol;

		}

	}

	/**

	 * Fills the comboboxes that are placed in the panel with the classifying field names of the layer

	 * which contain numerical information

	 *

	 */

	private void fillFieldNames() {

		DataSource rs;

		try {

			rs = ((AlphanumericData) myLayer).getRecordset();

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

			rs.start();

			int cont = 0;

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

				if(isNumericField(rs.getFieldType(i)))

					cont++;

			}

			String[] nomFields = new String[cont];

			cont = 0;

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

				if (isNumericField(rs.getFieldType(i))) {

					nomFields[cont] = rs.getFieldName(i).trim();

					cont++;

				}

			}

			rs.stop();

			this.fieldNames = nomFields;

			DefaultComboBoxModel cMValue = new DefaultComboBoxModel(this.fieldNames);

			DefaultComboBoxModel cMNormalization = new DefaultComboBoxModel(this.fieldNames);

			cmbValue.setModel(cMValue);

			cmbNormalization.setModel(cMNormalization);

			cmbNormalization.addItem(noNormalization);

		} catch (ReadDriverException e) {

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

		}

	}

	public void setData(FLayer lyr, ILegend legend) {

		this.myLayer = (ClassifiableVectorial) lyr;

		fillFieldNames();

		try {

			templateShapeType = (this.myLayer.getShapeType() == FShape.POLYGON) ? FShape.POINT : this.myLayer.getShapeType();

			getTemplSymbol().setShapeType(templateShapeType);

			if(myLayer.getShapeType() == FShape.POLYGON && backgroundPanel == null)

				symbolPanel.add(getBackgroundPanel());

		} catch (ReadDriverException e) {

			NotificationManager.addError(PluginServices.getText(this, "error accessing to the layer"), e);

		}

		if (ProportionalSymbolsLegend.class.equals(legend.getClass())) {

			auxLegend = (ProportionalSymbolsLegend) legend;

			cmbValue.setSelectedItem(auxLegend.getClassifyingFieldNames()[0]);

			ISymbol defSymbol = auxLegend.getDefaultSymbol();

			if(((ProportionalSymbolsLegend) auxLegend).getUseNormalization())

				cmbNormalization.setSelectedItem(auxLegend.getClassifyingFieldNames()[1]);

			else cmbNormalization.setSelectedItem(noNormalization);

			txtMaxSize.setDouble(auxLegend.getMaxSize());

			txtMinSize.setDouble(auxLegend.getMinSize());

			getTemplSymbol().setSymbol(defSymbol);

			if(((ProportionalSymbolsLegend) auxLegend).getBackgroundSymbol() != null)

				getBtnBackground().setSymbol(((ProportionalSymbolsLegend) auxLegend).getBackgroundSymbol());

			action.actionPerformed(new ActionEvent(txtMinSize, 0, "no_hace_falta"));

		} else {

			auxLegend = new ProportionalSymbolsLegend();

			auxLegend.setTemplateShapeType(templateShapeType);

			auxLegend.setDefaultSymbol(newSymbol(templateShapeType, templateShapeType == FShape.LINE ? 3 : 10));

			getTemplSymbol().setSymbol(auxLegend.getDefaultSymbol());

			if(templateShapeType == FShape.LINE) {

				txtMinSize.setDouble(3);

				txtMaxSize.setDouble(3);

			}

			else {

				txtMinSize.setDouble(10);

				txtMaxSize.setDouble(10);

			}

		}

	}

	public ILegend getLegend() {

		theLegend = new ProportionalSymbolsLegend();

		String[] fieldNames = new String[2];

		fieldNames[0]= cmbValue.getSelectedItem().toString();

		if(!useNormalization)

			fieldNames[1]= fieldNames[0];

		else fieldNames[1]= cmbNormalization.getSelectedItem().toString();

		auxLegend.setTemplateShapeType(templateShapeType);

		auxLegend.setValueField(cmbValue.getSelectedItem().toString());

		auxLegend.setNormalizationField(cmbNormalization.getSelectedItem().toString());

		auxLegend.setUseNormalization(useNormalization);

		auxLegend.setMinSize(txtMinSize.getDouble());

		auxLegend.setMaxSize(txtMaxSize.getDouble());

		ISymbol symbol = getTemplSymbol().getSymbol();

		symbol.setDescription(getSymbolDescription());

		auxLegend.setDefaultSymbol(symbol);

		auxLegend.addSymbol(ValueFactory.createValue("defaultSymbol"), symbol);

		auxLegend.setBackgroundSymbol(getBtnBackground().getSymbol());

		auxLegend.setClassifyingFieldNames(fieldNames);

		DataSource recordSet = null;

		try {

			recordSet = ((AlphanumericData) myLayer).getRecordset();

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

				double min = 0, max = 0;

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

					Value val = recordSet.getFieldValue(j, recordSet.getFieldIndexByName(fieldNames[i]));

					double dob = Double.valueOf(val.toString());

					if (dob < min) min = dob;

					if (dob > max) max = dob;

				}

				if(i == 0) {

					auxLegend.setMinFeature(min);

					auxLegend.setMaxFeature(max);

				}

			}

		} catch (ReadDriverException e) {

			NotificationManager.addError("error_accessing_to_the_layer",e);

		}

		theLegend = auxLegend;

		return theLegend;

	}

	/**

	 * Creates the String which will be the description of the symbol. If the selected normalization field

	 * is not "None", then the String created will have this structure ValueField/NormalizationField. Else,

	 * if the user select "None" for the normalization field,the string will show the ValueField only.

	 *

	 * @return String	description for the symbol

	 */

	private String getSymbolDescription() {

		String description = "";

		if (cmbValue.getSelectedItem() != null)

			description += cmbValue.getSelectedItem().toString();

		if (cmbNormalization.getSelectedItem().toString().compareTo(noNormalization) != 0 )

			description += " / "+cmbNormalization.getSelectedItem().toString();

		return description;

	}

	public String getDescription() {

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

	}

	public ImageIcon getIcon() {

		// TODO Implement it

		return null;

	}

	public Class getParentClass() {

		return Quantities.class;

	}

	public String getTitle() {

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

	}

	public Class getLegendClass() {

		return ProportionalSymbolsLegend.class;

	}

	/**

	 * Checks if an specific field contains numerical data

	 *

	 * @param fieldType	index of the field

	 *

	 * @return boolean	true or false depending on the type of data (numerical or not)

	 */

	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;

		}

	}

	public boolean isSuitableFor(FLayer layer) {

		if (layer instanceof FLyrVect) {

			FLyrVect lyr = (FLyrVect) layer;

			try {

				if (lyr.getShapeType() == FShape.MULTI)

					return false;

				SelectableDataSource sds;

				sds = ((FLyrVect) layer).getRecordset();

				String[] fNames = sds.getFieldNames();

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

					if (isNumericField(sds.getFieldType(i))) {

						return true;

					}

				}

			} catch (ReadDriverException e) {

				return false;

			}

		}

		return false;

	}

	public JPanel getPanel() {

		return this;

	}

	private ActionListener action = new ActionListener() {

		public void actionPerformed(ActionEvent e) {

			if (e.getSource().equals(cmbValue)) {

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

				auxLegend.setValueField(cb.getSelectedItem().toString());

			}

			if (e.getSource().equals(cmbNormalization)) {

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

				if(cb.getSelectedItem().toString().compareTo(noNormalization) == 0) {

					useNormalization = false;

					auxLegend.setNormalizationField(cmbValue.getSelectedItem().toString());

				}

				else {

					useNormalization = true;

					auxLegend.setNormalizationField(cb.getSelectedItem().toString());

				}

				auxLegend.setUseNormalization(useNormalization);

			}

			if (e.getSource().equals(txtMinSize)) {

//				ISymbol sym = tmplateSymbol.getSymbol();

//				if(sym != null) {

//					if(sym instanceof ILineSymbol) {

//						ILineSymbol line = (ILineSymbol)sym;

//						line.setLineWidth(txtMinSize.getDouble());

//						tmplateSymbol.setSymbol(line);

//					}

//

//					if(sym instanceof IMarkerSymbol) {

//						IMarkerSymbol point = (IMarkerSymbol)sym;

//						point.setSize(txtMinSize.getDouble());

//						tmplateSymbol.setSymbol(point);

//					}

//					tmplateSymbol.repaint();

//				}

				if(txtMaxSize.getDouble() < txtMinSize.getDouble())

					txtMaxSize.setDouble(txtMinSize.getDouble());

			}

			if(e.getSource().equals(txtMaxSize)) {

				if(txtMaxSize.getDouble() < txtMinSize.getDouble())

					txtMinSize.setDouble(txtMaxSize.getDouble());

			}

			if(e.getSource().equals(tmplateSymbol)) {

				ISymbol sym = tmplateSymbol.getSymbol();

				if(sym != null) {

					if(sym instanceof ILineSymbol) {

						ILineSymbol line = (ILineSymbol)sym;

						txtMinSize.setDouble(((int)line.getLineWidth()));

						txtMaxSize.setDouble(((int)line.getLineWidth()));

					}

					if(sym instanceof IMarkerSymbol) {

						IMarkerSymbol point = (IMarkerSymbol)sym;

						txtMinSize.setDouble(((int)point.getSize()));

						txtMaxSize.setDouble(((int)point.getSize()));

					}

				}

			}

		}

	};

}