Application: gvSIG desktop » gvSIG legends: base legends

<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">

	<modelVersion>4.0.0</modelVersion>

	<artifactId>org.gvsig.legend.proportionalsymbols.app.mainplugin</artifactId>

	<name>Vector legend: Proportional symbols</name>

	<version>1.0.242</version>

  <parent>

      <groupId>org.gvsig</groupId>

      <artifactId>org.gvsig.desktop</artifactId>

      <version>2.0.445</version>

  </parent>

	<url>https://devel.gvsig.org/redmine/projects/gvsig-base-legends</url>

    <scm>

        <connection>scm:svn:https://devel.gvsig.org/svn/gvsig-base-legends/org.gvsig.legend.proportionalsymbols.app.mainplugin/tags/org.gvsig.legend.proportionalsymbols.app.mainplugin-1.0.242</connection>

        <developerConnection>scm:svn:https://devel.gvsig.org/svn/gvsig-base-legends/org.gvsig.legend.proportionalsymbols.app.mainplugin/tags/org.gvsig.legend.proportionalsymbols.app.mainplugin-1.0.242</developerConnection>

        <url>scm:svn:https://devel.gvsig.org/svn/gvsig-base-legends/org.gvsig.legend.proportionalsymbols.app.mainplugin/tags/org.gvsig.legend.proportionalsymbols.app.mainplugin-1.0.242</url>

    </scm>

    <repositories>

      <repository>

        <id>gvsig-public-http-repository</id>

        <name>gvSIG maven public HTTP repository</name>

        <url>http://devel.gvsig.org/m2repo/j2se</url>

        <releases>

          <enabled>true</enabled>

          <updatePolicy>daily</updatePolicy>

          <checksumPolicy>warn</checksumPolicy>

        </releases>

        <snapshots>

          <enabled>true</enabled>

          <updatePolicy>daily</updatePolicy>

          <checksumPolicy>warn</checksumPolicy>

        </snapshots>

      </repository>

    </repositories>

	<description>Vector legend: Proportional symbols. The symbol size is exactly proportional to the numeric attribute value.</description>

	<build>

        <plugins>

		    <plugin>

		      <artifactId>maven-release-plugin</artifactId>

		      <configuration>

		        <tagBase>https://devel.gvsig.org/svn/gvsig-base-legends/org.gvsig.legend.proportionalsymbols.app.mainplugin/tags</tagBase>

		      </configuration>

		    </plugin>

        </plugins>

	</build>

	<dependencies>

		<dependency>

			<groupId>org.gvsig</groupId>

			<artifactId>org.gvsig.app.mainplugin</artifactId>

		</dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.andami</artifactId>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.symbology.lib.api</artifactId>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.symbology.lib.impl</artifactId>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.symbology.swing.api</artifactId>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.fmap.mapcontext.api</artifactId>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.utils</artifactId>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.fmap.dal.api</artifactId>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.i18n</artifactId>

        </dependency>

		<dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.fmap.geometry.api</artifactId>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.tools.lib</artifactId>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.ui</artifactId>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.projection.api</artifactId>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.metadata.lib.basic.api</artifactId>

        </dependency>

	</dependencies>

	<properties>

	    <gvsig.package.info.categories>View,Vector,Symbology</gvsig.package.info.categories>

        <gvsig.package.info.official>true</gvsig.package.info.official>

        <gvsig.package.info.dependencies>required: org.gvsig.app.mainplugin -ge 2.1.0-A</gvsig.package.info.dependencies>

        <gvsig.package.info.state>testing</gvsig.package.info.state>

		<gvsig.package.info.poolURL>https://devel.gvsig.org/download/projects/gvsig-base-legends/pool</gvsig.package.info.poolURL>

	</properties>

</project>

#Fri Apr 12 11:08:09 CEST 2024

buildNumber=246

<!--

    gvSIG. Desktop Geographic Information System.

    Copyright (C) 2007-2013 gvSIG Association.

    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 3

    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., 51 Franklin Street, Fifth Floor, Boston,

    MA  02110-1301, USA.

    For any additional information, do not hesitate to contact us

    at info AT gvsig.com, or visit our website www.gvsig.com.

-->

<assembly>

  <id>gvsig-plugin-package</id>

  <formats>

    <format>zip</format>

  </formats>

  <baseDirectory>${project.artifactId}</baseDirectory>

  <includeBaseDirectory>true</includeBaseDirectory>

  <files>

    <file>

      <source>target/${project.artifactId}-${project.version}.jar</source>

      <outputDirectory>lib</outputDirectory>

    </file>

    <file>

      <source>target/package.info</source>

    </file>

  </files>

  <fileSets>

    <fileSet>

      <directory>src/main/resources-plugin</directory>

      <outputDirectory>.</outputDirectory>

    </fileSet>

  </fileSets>

<!-- No dependencies

  <dependencySets>

    <dependencySet>

      <useProjectArtifact>false</useProjectArtifact>

      <useTransitiveDependencies>false</useTransitiveDependencies>

      <outputDirectory>lib</outputDirectory>

      <includes>

		<include>...</include>

      </includes>

    </dependencySet>

  </dependencySets>

-->

</assembly>

/* 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.fmap.rendering;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

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

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryManager;

import org.gvsig.fmap.mapcontext.MapContextLocator;

import org.gvsig.fmap.mapcontext.MapContextManager;

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

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

import org.gvsig.fmap.mapcontext.rendering.legend.events.IntervalLegendEvent;

import org.gvsig.fmap.mapcontext.rendering.legend.events.LabelLegendEvent;

import org.gvsig.fmap.mapcontext.rendering.legend.events.LegendChangedEvent;

import org.gvsig.fmap.mapcontext.rendering.legend.events.LegendClearEvent;

import org.gvsig.fmap.mapcontext.rendering.legend.events.SymbolLegendEvent;

import org.gvsig.fmap.mapcontext.rendering.legend.events.ValueLegendEvent;

import org.gvsig.fmap.mapcontext.rendering.symbols.IMultiLayerSymbol;

import org.gvsig.fmap.mapcontext.rendering.symbols.ISymbol;

import org.gvsig.i18n.Messages;

import org.gvsig.symbology.fmap.mapcontext.rendering.legend.impl.VectorialUniqueValueLegend;

import org.gvsig.symbology.fmap.mapcontext.rendering.symbol.fill.impl.MarkerFillSymbol;

import org.gvsig.symbology.fmap.mapcontext.rendering.symbol.fill.impl.MultiLayerFillSymbol;

import org.gvsig.symbology.fmap.mapcontext.rendering.symbol.line.ILineSymbol;

import org.gvsig.symbology.fmap.mapcontext.rendering.symbol.marker.IMarkerSymbol;

import org.gvsig.symbology.fmap.mapcontext.rendering.symbol.style.SimpleMarkerFillPropertiesStyle;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DynStruct;

import org.gvsig.tools.persistence.PersistenceManager;

import org.gvsig.tools.persistence.PersistentState;

import org.gvsig.tools.persistence.exception.PersistenceException;

import org.gvsig.tools.util.Callable;

/**

 * Implements a legend which represents the quantitative information

 * (numeric values). This representation is possible thanks to a symbol

 * whose size is different each time (depending on the numeric values

 * and if we want to use normalization or not).

 *

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

 * @author jldominguez

 */

public class ProportionalSymbolsLegend extends VectorialUniqueValueLegend  {

    private static Logger logger = LoggerFactory.getLogger(ProportionalSymbolsLegend.class);

    public static final String

    PROPORTIONAL_SYMBOL_LEGEND_NAME =

        "PROPORTIONAL_SYMBOL_LEGEND";

    public static final String

    PROPORTIONAL_SYMBOL_LEGEND_PERSISTENCE_DEFINITION_NAME =

        "PROPORTIONAL_SYMBOL_LEGEND_PERSISTENCE_DEFINITION";

	public void setClassifyingFieldNames(String[] fNames) {

		super.setClassifyingFieldNames(fNames);

		valueField = fNames[0];

		normalizationField = fNames[1];

	}

	private ISymbol backgroundSymbol;

	private String valueField;

	private String normalizationField;

	private double minSize;

	private double maxSize;

	private int templateShapeType;

	private boolean useNormalization;

	private double maxFeature, minFeature;

	private ZSort zSort = null;

	public ISymbol getSymbolByValue(Object key) {

		return null;

	}

	public ISymbol getSymbolByFeature(Feature feat) {

		ISymbol theSymbol = getDefaultSymbol();

		ISymbol auxSymbol;

		double value = 0;

		double normValue = 0;

		double size;

		double separation = maxSize-minSize;

		if (separation == 0) {

			separation = 1;

		}

		try {

			value = feat.getDouble(this.valueField);

			if (useNormalization) {

			    normValue = feat.getDouble(this.normalizationField);

			    if (normValue == 0) {

			        size = (value >= 0) ?

			            Double.POSITIVE_INFINITY :

			            Double.NEGATIVE_INFINITY;

			    } else {

	                value = value / normValue;

	                size = minSize + (value * separation) ;

			    }

			} else {

				double difFeat = maxFeature - minFeature;

				double step = difFeat/separation;

				size = minSize + ((value - minFeature)/step);

			}

		} catch (Exception e) {

			logger.info("Error while getting value in ProportionalSymbolsLegend.", e);

			return null;

		}

		if (size == Double.NaN || size == Double.POSITIVE_INFINITY

		    || size == Double.NEGATIVE_INFINITY) {

            // logger.info("The symbol size is NaN or INFINITE.");

			return null;

		}

		Geometry defgeom = feat.getDefaultGeometry();

		int def_geom_type = defgeom.getGeometryType().getType();

		if (isPolygonal(def_geom_type) && theSymbol instanceof IMarkerSymbol) {

			MarkerFillSymbol aux = new MarkerFillSymbol();

			((IMarkerSymbol) theSymbol).setSize(size);

			aux.setMarker((IMarkerSymbol) theSymbol);

			SimpleMarkerFillPropertiesStyle p = new SimpleMarkerFillPropertiesStyle();

			p.setFillStyle(SimpleMarkerFillPropertiesStyle.SINGLE_CENTERED_SYMBOL);

			aux.setMarkerFillProperties(p);

			theSymbol = aux;

		}

		else if (isLinear(def_geom_type)) {

			ILineSymbol line = (ILineSymbol) theSymbol;

			line.setLineWidth(size);

			theSymbol = line;

		}

		else if (isPoint(def_geom_type)) {

			IMarkerSymbol marker = (IMarkerSymbol) theSymbol;

			marker.setSize(size);

			theSymbol = marker;

		}

		if (backgroundSymbol != null) {

			MultiLayerFillSymbol multi = new MultiLayerFillSymbol() ;

			multi.addLayer(backgroundSymbol);

			multi.addLayer(theSymbol);

			return multi;

		}

		auxSymbol = theSymbol;

		return auxSymbol;

	}

    public static boolean isPolygonal(int ty) {

        GeometryManager geomManager = GeometryLocator.getGeometryManager();

        return geomManager.isSubtype(Geometry.TYPES.MULTISURFACE, ty) || 

            geomManager.isSubtype(Geometry.TYPES.SURFACE, ty);

    }

    public static boolean isLinear(int ty) {

        GeometryManager geomManager = GeometryLocator.getGeometryManager();

        return geomManager.isSubtype(Geometry.TYPES.MULTICURVE, ty) || 

            geomManager.isSubtype(Geometry.TYPES.CURVE, ty);

    }

    public static boolean isPoint(int ty) {

        GeometryManager geomManager = GeometryLocator.getGeometryManager();

        return geomManager.isSubtype(Geometry.TYPES.MULTIPOINT, ty) || 

            geomManager.isSubtype(Geometry.TYPES.POINT, ty);

    }

	/**

	 * Gets the background symbol which only can appear when the shapetype of the layer

	 * is polygonal

	 *

	 * @return ISymbol the symbol for the background

	 */

	public ISymbol getBackgroundSymbol() {return backgroundSymbol;}

	/**

	 * Sets the background symbol which is used only when the shapetype of the layer is polygonal

	 *

	 * @param backgroundSymbol the symbol for the background

	 */

	public void setBackgroundSymbol(ISymbol backgroundSymbol) {this.backgroundSymbol = backgroundSymbol;}

	/**

	 * Obtains the classifying field name to be used to calculate the size of the symbol

	 *

	 * @return String  the name of the field

	 * @throws ReadDriverException

	 */

	public String getValueField() {

//		try {

//			// TODO:

//			// Por los alias, al guardar un proyecto no podemos

//			// permitir que se guarde con campos que luego

//			// no van a existir.

////			int id = dataSource.getFieldIndexByName(valueField);

////			valueField = dataSource.getFieldName(id);

//		} catch (ReadDriverException e) {

//			e.printStackTrace();

//			throw new RuntimeException(e);

//		}

		return valueField;

	}

	/**

	 * Sets the classifying field name to be used to calculate the size of the symbol

	 *

	 * @param String  the name of the field

	 */

	public void setValueField(String valueField) {this.valueField = valueField;}

	/**

	 * Obtains the classifying field name to be used to calculate the size of the symbol when the

	 * user is doing it with a normalization value.

	 *

	 * @return String  the name of the field

	 */

	public String getNormalizationField() {

		return normalizationField;

	}

	/**

	 * Sets the classifying field name to be used to calculate the size of the symbol when the

	 * user is doing it with a normalization value.

	 *

	 * @param String  the name of the field

	 */

	public void setNormalizationField(String normalizationField) {this.normalizationField = normalizationField;}

	/**

	 * Obtains the minimum size for the symbol

	 *

	 * @return double  the minimum size for the symbol

	 */

	public double getMinSize() {return minSize;}

	/**

	 * Sets the minimum size for the symbol

	 *

	 * @param minSize  the minimum size for the symbol

	 */

	public void setMinSize(double minSize) {this.minSize = minSize;}

	/**

	 * Obtains the maximum size for the symbol

	 *

	 * @return double  the minimum size for the symbol

	 */

	public double getMaxSize() {return maxSize;}

	/**

	 * Sets the maximum size for the symbol

	 *

	 * @param maxSize  the minimum size for the symbol

	 */

	public void setMaxSize(double maxSize) {this.maxSize = maxSize;}

	/**

	 * Obtains the shapetype of the template symbol

	 *

	 * @return int shape type for the template symbol

	 */

	public int getTemplateShapeType() {return templateShapeType;}

	/**

	 * Sets the shapetype of the template symbol

	 *

	 * @param templateShapeType shape type for the template symbol

	 */

	public void setTemplateShapeType(int tst) {

		if (isPolygonal(getShapeType())) {

			if (isPoint(tst) || isPolygonal(tst)) {

			    this.templateShapeType = tst;

			}

		} else {

		    if ((isPoint(tst) && isPoint(getShapeType()))

		        || (isLinear(tst) && isLinear(getShapeType()))) {

		        // || (getShapeType() == Geometry.TYPES.NULL)) {

		        this.templateShapeType = tst;

		    }

		}

	}

	/**

	 * Obtains the boolean which is true if the user wants to calculate the size of the

	 * symbol using a normalization field.

	 *

	 * @return boolean true if the user wants normalization.Otherwise, false.

	 */

	public boolean getUseNormalization() {return useNormalization;}

	/**

	 * Sets the boolean which is true if the user wants to calculate the size of the

	 * symbol using a normalization field.

	 *

	 * @param useNormalization true if the user wants normalization.Otherwise, false.

	 */

	public void setUseNormalization(boolean useNormalization) {this.useNormalization = useNormalization;}

	/**

	 * Obtains the variable which represents the maximum value of the classifying field that is used

	 * to calculate the size of the symbol

	 *

	 * @return double  the maximum value of the classifying field

	 */

	public double getMaxFeature() {return maxFeature;}

	/**

	 * Sets the variable which represents the maximum value of the classifying field that is used

	 * to calculate the size of the symbol

	 *

	 * @param maxFeature

	 */

	public void setMaxFeature(double maxFeature) {this.maxFeature = maxFeature;}

	/**

	 * Obtains the variable which represents the minimum value of the classifying field that is used

	 * to calculate the size of the symbol

	 *

	 * @return double  the minimum value of the classifying field

	 */

	public double getMinFeature() {return minFeature;}

	/**

	 * Sets the variable which represents the minimum value of the classifying field that is used

	 * to calculate the size of the symbol

	 *

	 * @param minFeature

	 */

	public void setMinFeature(double minFeature) {this.minFeature = minFeature;}

	public ISymbol[] getSymbols() {

		ISymbol[] auxSymbols=super.getSymbols();

		if(backgroundSymbol != null){

			ISymbol[] symbols=new ISymbol[auxSymbols.length+1];

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

				symbols[i]=auxSymbols[i];

			}

			symbols[symbols.length-1]=backgroundSymbol;

			return symbols;

		} else {

			return auxSymbols;

		}

	}

	public ZSort getZSort() {

		if (zSort == null){

			zSort = new MyZSort(this);

		}

		return zSort;

	}

	public void setZSort(ZSort zSort){

		return;

	}

	private class MyZSort extends ZSort {

		public MyZSort(ILegend legend) {

			super(legend);

		}

		public void legendChanged(LegendChangedEvent e) {

		}

		public String getClassName() {

			return getClass().getName();

		}

		public int getLevelCount() {

			int levels = 0;

			if (backgroundSymbol!=null){

				if(backgroundSymbol instanceof IMultiLayerSymbol){

					levels += ((IMultiLayerSymbol)backgroundSymbol).getLayerCount();

				} else {

					levels += 1;

				}

			}

			ISymbol sym = getDefaultSymbol();

			if(getDefaultSymbol() instanceof IMultiLayerSymbol){

				levels += ((IMultiLayerSymbol)sym).getLayerCount();

			} else {

				levels += 1;

			}

			return levels+1;

		}

		public void setUsingZSort(boolean usingZSort) {

		}

		public void setLevels(ISymbol sym, int[] values) {

		}

		public void setLevels(int row, int[] values) {

		}

		public int[] getLevels(ISymbol sym) {

			return getLevels(0);

		}

		public int[] getLevels(int row) {

			int levelsCount = getLevelCount();

			int[] levels = new int[levelsCount];

			int bgLevels = 1;

			if (backgroundSymbol!=null){

				if(backgroundSymbol instanceof IMultiLayerSymbol){

					bgLevels = ((IMultiLayerSymbol)backgroundSymbol).getLayerCount();

				}

				for (int i=0; i<bgLevels; i++) {

					levels[i]=i;

				}

			}

			ISymbol sym = getDefaultSymbol();

			int frLevels = 1;

			if(getDefaultSymbol() instanceof IMultiLayerSymbol){

				frLevels = ((IMultiLayerSymbol)sym).getLayerCount();

			}

			for (int i=0; i<frLevels; i++) {

				levels[i+bgLevels]=i+bgLevels;

			}

			levels[frLevels+bgLevels]=frLevels+bgLevels;

			return levels;

		}

		public boolean isUsingZSort() {

			return backgroundSymbol!=null;

		}

		public ISymbol[] getSymbols() {

			return getSymbols();

		}

		public String[] getDescriptions() {

			return getDescriptions();

		}

		public int getTopLevelIndexAllowed() {

			return getLevelCount();

		}

		@Override

		public String toString() {

			String out = "ZSort for ProportionalSymbolLegend";

			return out;

		}

		public boolean symbolChanged(SymbolLegendEvent e) {

			return true;

		}

		public boolean classifiedSymbolChange(SymbolLegendEvent e) {

			return true;

		}

		public boolean intervalChange(IntervalLegendEvent e) {

			return false;

		}

		public boolean valueChange(ValueLegendEvent e) {

			return false;

		}

		// TODO should not exist here

		public boolean labelFieldChange(LabelLegendEvent e) {

			return false;

		}

		public void legendCleared(LegendClearEvent event) {

		}

	}

    public void loadFromState(PersistentState state)

        throws PersistenceException {

        int[] ft = state.getIntArray("fieldTypes");

        this.setClassifyingFieldTypes(ft);

        this.valueField = state.getString("valueField");

        this.normalizationField = state.getString("normalizationField");

        this.templateShapeType = state.getInt("templateShapeType");

        this.maxSize = state.getDouble("maxSize");

        this.minSize = state.getDouble("minSize");

        this.maxFeature = state.getDouble("maxFeature");

        this.minFeature = state.getDouble("minFeature");

        this.useNormalization = state.getBoolean("useNormalization");

        ISymbol sym = (ISymbol) state.get("defaultSymbol");

        this.setDefaultSymbol(sym);

        sym = (ISymbol) state.get("backgroundSymbol");

        this.setBackgroundSymbol(sym);

        String[] fieldNames = new String[2];

        fieldNames[0]= valueField;

        if (normalizationField.compareTo(Messages.getText("none")) == 0) {

            fieldNames[1]= fieldNames[0];

        } else {

            fieldNames[1] = normalizationField;

        }

        setClassifyingFieldNames(fieldNames);

    }

    public void saveToState(PersistentState state) throws PersistenceException {

        int[] ft = this.getClassifyingFieldTypes();

        state.set("fieldTypes", ft);

        state.set("valueField", this.valueField);

        state.set("normalizationField", this.normalizationField);

        state.set("templateShapeType", this.templateShapeType);

        state.set("maxSize", this.maxSize);

        state.set("minSize", this.minSize);

        state.set("maxFeature", this.maxFeature);

        state.set("minFeature", this.minFeature);

        state.set("useNormalization", this.useNormalization);

        state.set("defaultSymbol", this.getDefaultSymbol());

        state.set("backgroundSymbol", this.backgroundSymbol);

    }

    public static class RegisterPersistence implements Callable {

        public Object call() throws Exception {

            PersistenceManager manager = ToolsLocator.getPersistenceManager();

            if (manager

                .getDefinition(PROPORTIONAL_SYMBOL_LEGEND_PERSISTENCE_DEFINITION_NAME) == null) {

                DynStruct definition =

                    manager

                        .addDefinition(

                            ProportionalSymbolsLegend.class,

                            PROPORTIONAL_SYMBOL_LEGEND_PERSISTENCE_DEFINITION_NAME,

                            PROPORTIONAL_SYMBOL_LEGEND_PERSISTENCE_DEFINITION_NAME

                                + " Persistence definition", null, null);

                definition.addDynFieldString("valueField").setMandatory(true);

                definition.addDynFieldString("normalizationField").setMandatory(true);

                definition.addDynFieldInt("templateShapeType").setMandatory(true);

                definition.addDynFieldArray("fieldTypes").setClassOfItems(Integer.class).setMandatory(true);

                definition.addDynFieldDouble("maxSize").setMandatory(true);

                definition.addDynFieldDouble("minSize").setMandatory(true);

                definition.addDynFieldDouble("maxFeature").setMandatory(true);

                definition.addDynFieldDouble("minFeature").setMandatory(true);

                definition.addDynFieldBoolean("useNormalization").setMandatory(true);

                definition.addDynFieldObject("defaultSymbol")

                .setClassOfValue(ISymbol.class).setMandatory(true);

                definition.addDynFieldObject("backgroundSymbol")

                .setClassOfValue(ISymbol.class).setMandatory(true);

            }

            return Boolean.TRUE;

        }

    }

    public static class RegisterLegend implements Callable {

        public Object call() throws Exception {

            MapContextManager manager =

                MapContextLocator.getMapContextManager();

            manager.registerLegend(

                PROPORTIONAL_SYMBOL_LEGEND_NAME,

                ProportionalSymbolsLegend.class);

            return Boolean.TRUE;

        }

    }

}

/* 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 javax.swing.BorderFactory;

import javax.swing.DefaultComboBoxModel;

import javax.swing.ImageIcon;

import javax.swing.JComboBox;

import javax.swing.JLabel;

import javax.swing.JOptionPane;

import javax.swing.JPanel;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.gvsig.andami.IconThemeHelper;

import org.gvsig.app.ApplicationLocator;

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

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.geom.Geometry;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryManager;

import org.gvsig.fmap.mapcontext.MapContextLocator;

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

import org.gvsig.fmap.mapcontext.layers.operations.ClassifiableVectorial;

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

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

import org.gvsig.fmap.mapcontext.rendering.symbols.ISymbol;

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

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

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

import org.gvsig.i18n.Messages;

import org.gvsig.symbology.fmap.mapcontext.rendering.symbol.fill.impl.MarkerFillSymbol;

import org.gvsig.symbology.fmap.mapcontext.rendering.symbol.line.ILineSymbol;

import org.gvsig.symbology.fmap.mapcontext.rendering.symbol.line.impl.SimpleLineSymbol;

import org.gvsig.symbology.fmap.mapcontext.rendering.symbol.marker.IMarkerSymbol;

import org.gvsig.symbology.fmap.mapcontext.rendering.symbol.marker.impl.SimpleMarkerSymbol;

import org.gvsig.symbology.fmap.mapcontext.rendering.symbol.style.IMarkerFillPropertiesStyle;

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

import org.gvsig.tools.dispose.DisposableIterator;

/**

 * 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

 * @author jldominguez

 */

public class ProportionalSymbolsPanel extends JPanel implements ILegendPanel {

    private static Logger logger = LoggerFactory.getLogger(ProportionalSymbolsPanel.class);

    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 JNumberSpinner txtMinSize;

    private JNumberSpinner txtMaxSize;

    private ClassifiableVectorial myLayer;

    private ProportionalSymbolsLegend auxLegend;

    private String[] fieldNames;

    private int templateShapeType = 0;

    private String noNormalization = Messages.getText("none");

    private boolean useNormalization = true;

    /**

     * Default constructor

     */

    public ProportionalSymbolsPanel() {

        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,

                        Messages.getText("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(

                Messages.getText("value")

                + ":"));

        fieldsPanel.add(cmbValue);

        fieldsPanel.add(new JLabel(

                Messages.getText("normalization")

                + ":"));

        fieldsPanel.add(cmbNormalization);

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

        symbolPanel.setBorder(BorderFactory.

                createTitledBorder(null,

                        Messages.getText("symbol")

                ));

        GridBagLayoutPanel aux2 = new GridBagLayoutPanel();

        aux2.addComponent(new JLabel(

                Messages.getText("size")

        ));

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

        aux2.addComponent(

                Messages.getText("from")

                + ":",

                getTxtMinSize());

        aux2.addComponent(

                Messages.getText("to")

                + ":",

                getTxtMaxSize());

        JPanel templatePanel = new JPanel();

        templatePanel.setBorder(BorderFactory.createTitledBorder(null,

                Messages.getText("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,

                Messages.getText("background")

        ));

        backgroundPanel.add(getBtnBackground());

        return backgroundPanel;

    }

    /**

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

     * symbol

     *

     * @return JNumberSpinner

     */

    private JNumberSpinner getTxtMaxSize() {

        if (txtMaxSize == null) {

            txtMaxSize = new JNumberSpinner(25.0, 7, 0.0, 100.0, 1.0, 2);

            txtMaxSize.addActionListener(action);

        }

        return txtMaxSize;

    }

    /**

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

     * symbol

     *

     * @return JNumberSpinner

     */

    private JNumberSpinner getTxtMinSize() {

        if (txtMinSize == null) {

            txtMinSize = new JNumberSpinner(3.0, 7, 0.0, 100.0, 1.0, 2);

            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 tst = ProportionalSymbolsLegend.isPolygonal(this.templateShapeType)

                    ? Geometry.TYPES.POINT

                    : this.templateShapeType;

            tmplateSymbol = new JSymbolPreviewButton(tst);

        }

        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(Geometry.TYPES.SURFACE);

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

            ISymbol fillsym = MapContextLocator.getSymbolManager().createSymbol(

                    Geometry.TYPES.SURFACE, Color.ORANGE);

            backSymbol.setSymbol(fillsym);

        }

        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;

            GeometryManager geomManager = GeometryLocator.getGeometryManager();

            if (geomManager.isSubtype(Geometry.TYPES.POINT, shapeType)

                    || geomManager.isSubtype(Geometry.TYPES.MULTIPOINT, shapeType)

                    || geomManager.isSubtype(Geometry.TYPES.SURFACE, shapeType)

                    || geomManager.isSubtype(Geometry.TYPES.MULTISURFACE, shapeType)) {

                templateSymbol = new SimpleMarkerSymbol();

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

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

            } else if (geomManager.isSubtype(Geometry.TYPES.CURVE, shapeType)

                    || geomManager.isSubtype(Geometry.TYPES.MULTICURVE, shapeType)) {

                templateSymbol = new SimpleLineSymbol();

                ((SimpleLineSymbol) templateSymbol).setLineWidth(size);

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

            } else {

                throw new RuntimeException("Unknown symbol type");

            }

            getTemplSymbol().setSymbol(templateSymbol);

            return newSymbol(shapeType, size);

        } else {

            // clone symbol

            ISymbol mySymbol = getTemplSymbol().getSymbol();

            try {

                mySymbol = (ISymbol) mySymbol.clone();

            } catch (CloneNotSupportedException e) {

                logger.info("Error while cloning symbol", e);

                ApplicationLocator.getManager().messageDialog(

                        Messages.getText("_Unable_to_clone_symbol"),

                        Messages.getText("error"),

                        JOptionPane.ERROR_MESSAGE);

            }

            if (mySymbol instanceof ILineSymbol) {

                ILineSymbol lSym = (ILineSymbol) mySymbol;

                lSym.setLineWidth(size);

            }

            if (mySymbol instanceof IMarkerSymbol) {

                IMarkerSymbol mSym = (IMarkerSymbol) mySymbol;

                mSym.setSize(size);

                if (ProportionalSymbolsLegend.isPolygonal(shapeType)) {

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

        // SelectableDataSource rs;

        try {

            FeatureStore fsto = (FeatureStore) ((FLyrVect) myLayer).getDataStore();

            FeatureType fty = fsto.getDefaultFeatureType();

            FeatureAttributeDescriptor[] atts = fty.getAttributeDescriptors();

            int cont = 0;

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

                if (atts[i].getDataType().isNumeric()) {

                    cont++;

                }

            }

            String[] nomFields = new String[cont];

            cont = 0;

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

                if (atts[i].getDataType().isNumeric()) {

                    nomFields[cont] = atts[i].getName();

                    cont++;

                }

            }

            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 (DataException e) {

            logger.info("Error while getting fields", e);

            ApplicationLocator.getManager().messageDialog(

                    Messages.getText("_Error_while_getting_fields"),

                    Messages.getText("error"),

                    JOptionPane.ERROR_MESSAGE);

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

        }

    }

    public void setData(FLayer lyr, ILegend legend) {

        this.myLayer = (ClassifiableVectorial) lyr;

        fillFieldNames();

        int myt = Geometry.TYPES.GEOMETRY;

        try {

            myt = this.myLayer.getGeometryType().getType();

        } catch (ReadException re) {

            logger.info("Error while getting geometry type", re);

            ApplicationLocator.getManager().message(

                    "Error getting geometry type",

                    JOptionPane.ERROR_MESSAGE);

        }

        templateShapeType

                = ProportionalSymbolsLegend.isPolygonal(myt)

                ? Geometry.TYPES.POINT : myt;

        getTemplSymbol().setShapeType(templateShapeType);

        if (ProportionalSymbolsLegend.isPolygonal(myt) && backgroundPanel == null) {

            symbolPanel.add(getBackgroundPanel());

        }

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

            auxLegend = (ProportionalSymbolsLegend) legend.cloneLegend();

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

            if (ProportionalSymbolsLegend.isLinear(templateShapeType)) {

                ((ILineSymbol) defSymbol).setLineWidth(2);

            } else {

                ((IMarkerSymbol) defSymbol).setSize(15);

            }

            getTemplSymbol().setSymbol(defSymbol);

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

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

            }

        } else {

            auxLegend = new ProportionalSymbolsLegend();

            auxLegend.setTemplateShapeType(templateShapeType);

            if (ProportionalSymbolsLegend.isLinear(templateShapeType)) {

                auxLegend.setDefaultSymbol(newSymbol(templateShapeType, 2));

            } else {

                auxLegend.setDefaultSymbol(newSymbol(templateShapeType, 15));

            }

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

            if (ProportionalSymbolsLegend.isLinear(templateShapeType)) {

                txtMinSize.setDouble(3);

                txtMaxSize.setDouble(3);

            } else {

                txtMinSize.setDouble(10);

                txtMaxSize.setDouble(10);

            }

        }

    }

    public ILegend getLegend() {

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

        auxLegend.clear();

        ISymbol symbol = getTemplSymbol().getSymbol();

        symbol.setDescription(getSymbolDescription());

        auxLegend.setDefaultSymbol(symbol);

        auxLegend.setClassifyingFieldNames(fieldNames);

        // ==================================

        FLyrVect vect = (FLyrVect) myLayer;

        FeatureStore fsto = null;

        FeatureType fty = null;

        FeatureAttributeDescriptor[] atts = null;

        try {

            fsto = (FeatureStore) vect.getDataStore();

            fty = fsto.getDefaultFeatureType();

            int[] fieldTyp = new int[2];

            fieldTyp[0] = fty.getAttributeDescriptor(fieldNames[0]).getType();

            fieldTyp[1] = fty.getAttributeDescriptor(fieldNames[1]).getType();

            auxLegend.setClassifyingFieldTypes(fieldTyp);

            FeatureSet fset = fsto.getFeatureSet();

            DisposableIterator diter = fset.fastIterator();

            Feature fitem = null;

            double[] maxs = new double[fieldNames.length];

            double[] mins = new double[fieldNames.length];

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

                // init to worst values

                maxs[i] = -Double.MAX_VALUE;

                mins[i] = Double.MAX_VALUE;

            }

            double aux_dob = 0;

            while (diter.hasNext()) {

                fitem = (Feature) diter.next();

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

                    aux_dob = fitem.getDouble(fieldNames[i]);

                    if (aux_dob > maxs[i]) {

                        maxs[i] = aux_dob;

                    }

                    if (aux_dob < mins[i]) {

                        mins[i] = aux_dob;

                    }

                }

            }

            auxLegend.setMinFeature(mins[0]);

            auxLegend.setMaxFeature(maxs[0]);

        } catch (DataException e) {

            logger.info("Error while creating ProportionalSymbols legend", e);

            ApplicationLocator.getManager().message(

                    Messages.getText("_Error_while_creating_legend"),

                    JOptionPane.ERROR_MESSAGE);

        }

        //Just to avoid empty legend

        auxLegend.addSymbol(-Double.MAX_VALUE, symbol);

        if (auxLegend.isPolygonal(this.templateShapeType)) {

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

        }

        theLegend = (ProportionalSymbolsLegend) auxLegend.cloneLegend();

        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 Messages.getText(

                "draw_quantities_using_symbol_size_to_show_exact_values");

    }

    public ImageIcon getIcon() {

        return IconThemeHelper.getImageIcon(

                "legend-overview-proportional-symbols");

    }

    public Class getParentClass() {

        return Quantities.class;

    }

    public String getTitle() {

        return Messages.getText("proportional_symbols");

    }

    public Class getLegendClass() {

        return ProportionalSymbolsLegend.class;

    }

    public boolean isSuitableFor(FLayer layer) {

        if (layer instanceof FLyrVect) {

            FLyrVect lyr = (FLyrVect) layer;

            try {

                if (lyr.getShapeType() == Geometry.TYPES.GEOMETRY) {

                    return false;

                }

                FeatureStore fsto = (FeatureStore) lyr.getDataStore();

                FeatureType fty = fsto.getDefaultFeatureType();

                FeatureAttributeDescriptor[] atts = fty.getAttributeDescriptors();

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

                    if (atts[i].getDataType().isNumeric()) {

                        return true;

                    }

                }

            } catch (DataException e) {

                logger.info("Error in isSuitableFor", e);

                ApplicationLocator.getManager().message(

                        Messages.getText("_Error_while_checking_suitability"),

                        JOptionPane.ERROR_MESSAGE);

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

            }